home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume90 / unix / uucp106d / part03 < prev    next >
Internet Message Format  |  1990-06-28  |  64KB
  1. Path: xanth!cs.odu.edu!Amiga-Request
  2. From: Amiga-Request@cs.odu.edu (Amiga Sources/Binaries Moderator)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v90i181: UUCP 1.06D - UNIX compatible uucp/news/mail system, Part03/12
  5. Message-ID: <12972@xanth.cs.odu.edu>
  6. Date: 28 Jun 90 12:22:19 GMT
  7. Sender: news@cs.odu.edu
  8. Reply-To: Matt Dillon <@uunet.uu.net:overload!dillon>
  9. Lines: 2572
  10. Approved: tadguy@cs.odu.edu (Tad Guy)
  11. X-Mail-Submissions-To: Amiga@cs.odu.edu
  12. X-Post-Discussions-To: comp.sys.amiga
  13.  
  14. Submitted-by: Matt Dillon <@uunet.uu.net:overload!dillon>
  15. Posting-number: Volume 90, Issue 181
  16. Archive-name: unix/uucp-1.06d/part03
  17.  
  18. #!/bin/sh
  19. # This is a shell archive.  Remove anything before this line, then unpack
  20. # it by saving it into a file and typing "sh file".  To overwrite existing
  21. # files, type "sh file -c".  You can also feed this as standard input via
  22. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  23. # will see the following message at the end:
  24. #        "End of archive 3 (of 12)."
  25. # Contents:  uucp2/src/anews/raw.c uucp2/src/dmail/README
  26. #   uucp2/src/dmail/compat.c uucp2/src/dmail/dmail.h
  27. #   uucp2/src/dmail/help.c uucp2/src/dmail/set.c
  28. #   uucp2/src/include/config.h uucp2/src/include/lib_protos.h
  29. #   uucp2/src/include/uucico_protos.h uucp2/src/lib/lockfile.c
  30. #   uucp2/src/lib/ndir.c uucp2/src/lib/security.c
  31. #   uucp2/src/lib/serialport.c uucp2/src/util/from.c
  32. #   uucp2/src/util/inform.c uucp2/src/util/uusplit.c
  33. #   uucp2/src/uucico/uuxqt.c uucp2/src/uucico/version.doc
  34. #   uucp2/src/uuser/uuser.doc
  35. # Wrapped by tadguy@xanth on Thu Jun 28 08:21:18 1990
  36. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  37. if test -f 'uucp2/src/anews/raw.c' -a "${1}" != "-c" ; then 
  38.   echo shar: Will not clobber existing file \"'uucp2/src/anews/raw.c'\"
  39. else
  40. echo shar: Extracting \"'uucp2/src/anews/raw.c'\" \(3050 characters\)
  41. sed "s/^X//" >'uucp2/src/anews/raw.c' <<'END_OF_FILE'
  42. X
  43. X#if defined(LATTICE) || defined(_DCC)
  44. X
  45. X/*
  46. X * Routines specific to Lattice C.
  47. X */
  48. X
  49. X/*
  50. X * raw.c
  51. X *
  52. X * This is a routine for setting a given stream to raw or cooked mode on the
  53. X * Amiga. This is useful when you are using Lattice C to produce programs
  54. X * that want to read single characters with the "getch()" or "fgetc" call.
  55. X *
  56. X * Written : 18-Jun-87 By Chuck McManis.
  57. X */
  58. X
  59. X#include <exec/types.h>
  60. X#include <libraries/dos.h>
  61. X#include <libraries/dosextens.h>
  62. X
  63. X#ifdef LATTICE
  64. X#include <ios1.h>
  65. X#endif
  66. X#include <errno.h>
  67. X#include <stdio.h>
  68. X
  69. X/*
  70. X * Function raw() - Convert the specified file pointer to 'raw' mode. This
  71. X * only works on TTYs and essentially keeps DOS from translating keys for
  72. X * you, also (BIG WIN) it means getch() will return immediately rather than
  73. X * wait for a return. You lose editing features though.
  74. X */
  75. X
  76. Xlong
  77. Xraw(fp)
  78. XFILE *fp;
  79. X{
  80. X    struct MsgPort *mp;     /* The File Handle message port */
  81. X    struct FileHandle *afh;
  82. X    long        Arg[1], res;
  83. X
  84. X#ifdef LATTICE
  85. X    {
  86. X    struct UFB     *ufb;
  87. X    ufb = (struct UFB *) chkufb(fileno(fp));    /* Step one, get the file   */
  88. X    afh = (struct FileHandle *) (ufb->ufbfh);
  89. X    }
  90. X#else
  91. X    afh = (struct FileHandle *)fdtofh(fileno(fp));
  92. X#endif
  93. X
  94. X    if (!IsInteractive(afh)) {  /* Step two, check to see if it's a console */
  95. X    errno = ENOTTY;
  96. X    return (-1);
  97. X    }
  98. X    /* Step three, get it's message port. */
  99. X    mp = ((struct FileHandle *) (BADDR(afh)))->fh_Type;
  100. X    Arg[0] = -1L;
  101. X    res = SendPacket(mp, ACTION_SCREEN_MODE, Arg, 1);   /* Put it in RAW: mode */
  102. X    if (res == 0) {
  103. X    errno = ENXIO;
  104. X    return (-1);
  105. X    }
  106. X    return (0);
  107. X}
  108. X
  109. X/*
  110. X * Function - cooked() this function returns the designate file pointer to
  111. X * its normal, wait for a <CR> mode. This is exactly like raw() except that
  112. X * it sends a 0 to the console to make it back into a CON: from a RAW:
  113. X */
  114. X
  115. Xlong
  116. Xcooked(fp)
  117. XFILE *fp;
  118. X{
  119. X    struct MsgPort *mp;     /* The File Handle message port */
  120. X    struct FileHandle *afh;
  121. X    long        Arg[1], res;
  122. X
  123. X#ifdef LATTICE
  124. X    {
  125. X    struct UFB     *ufb;
  126. X    ufb = (struct UFB *) chkufb(fileno(fp));
  127. X    afh = (struct FileHandle *) (ufb->ufbfh);
  128. X    }
  129. X#else
  130. X    afh = (struct FileHandle *)fdtofh(fileno(fp));
  131. X#endif
  132. X
  133. X    if (!IsInteractive(afh)) {
  134. X    errno = ENOTTY;
  135. X    return (-1);
  136. X    }
  137. X    mp = ((struct FileHandle *) (BADDR(afh)))->fh_Type;
  138. X    Arg[0] = 0;
  139. X    res = SendPacket(mp, ACTION_SCREEN_MODE, Arg, 1);
  140. X    if (res == 0) {
  141. X    errno = ENXIO;
  142. X    return (-1);
  143. X    }
  144. X    return (0);
  145. X}
  146. X
  147. X#else            /*    ----------------------------------------------    */
  148. X
  149. X/*
  150. X * Routines specific to Aztec C.
  151. X */
  152. X
  153. X#include "news.h"
  154. X#include <sgtty.h>
  155. X#include <fcntl.h>
  156. X
  157. X/*
  158. X * put the console into raw or cooked mode
  159. X */
  160. X
  161. Xraw(FILE *f)
  162. X{
  163. X    struct sgttyb ttyinfo;
  164. X
  165. X    if (ioctl(fileno(f), TIOCGETP, &ttyinfo) < 0) return -1;
  166. X    ttyinfo.sg_flags |= RAW;
  167. X    if (ioctl(fileno(f), TIOCSETP, &ttyinfo) < 0) return -1;
  168. X    return 0;
  169. X}
  170. X
  171. Xcooked(FILE *f)
  172. X{
  173. X    struct sgttyb ttyinfo;
  174. X
  175. X    if (ioctl(fileno(f), TIOCGETP, &ttyinfo) < 0) return -1;
  176. X    ttyinfo.sg_flags &= ~RAW;
  177. X    if (ioctl(fileno(f), TIOCSETP, &ttyinfo) < 0) return -1;
  178. X    return 0;
  179. X}
  180. X
  181. X#endif
  182. X
  183. END_OF_FILE
  184. if test 3050 -ne `wc -c <'uucp2/src/anews/raw.c'`; then
  185.     echo shar: \"'uucp2/src/anews/raw.c'\" unpacked with wrong size!
  186. fi
  187. # end of 'uucp2/src/anews/raw.c'
  188. fi
  189. if test -f 'uucp2/src/dmail/README' -a "${1}" != "-c" ; then 
  190.   echo shar: Will not clobber existing file \"'uucp2/src/dmail/README'\"
  191. else
  192. echo shar: Extracting \"'uucp2/src/dmail/README'\" \(3002 characters\)
  193. sed "s/^X//" >'uucp2/src/dmail/README' <<'END_OF_FILE'
  194. X
  195. X    $Header: Beta:src/uucp/src/dmail/RCS/README,v 1.1 90/02/02 12:03:46 dillon Exp Locker: dillon $
  196. X
  197. XREADME FILE FOR DMAIL v1.12 distribution June 1989
  198. X
  199. XRead Makefile for compiling and installation procedures.
  200. X
  201. XDmail compiles fine on UNIX BSD 4.2/4.3. and the Amiga.  A man page exists
  202. Xand every command as a full help page online from Dmail.
  203. X
  204. XAN EXAMPLE OF A .DMAILRC FILE: (happens to be mine)
  205. X---------------------------------------------------------------------------
  206. Xalias normal    "setlist -s 18 From 38 Subject 10 To 0 Cc 0 Date"
  207. Xalias from    "setlist -s 66 From; list; normal"
  208. Xalias me    "select To dillon , Cc dillon"
  209. Xalias bugs    "select To root staff manag , Cc staff manag root"
  210. Xalias trek    "select To trek , Cc trek"
  211. Xalias notme    "select -s To !dillon; resel -s Cc !dillon; resel From !dillon"
  212. Xalias hack    "select To hacker , Cc hacker"
  213. Xalias page    set page more
  214. Xalias nopage    unset page
  215. Xalias k     tag
  216. Xalias kn    "tag ; next"
  217. Xalias spool    "g /usr/spool/mail/dillon ~/Dmail/mbox"
  218. Xalias keep    "g ~/Dmail/keep"
  219. Xalias mbox    "g ~/Dmail/mbox"
  220. Xalias q     "select -s all; write ~/Dmail/keep -s tag; delete -s tag; quit"
  221. Xalias g     "select -s all; write ~/Dmail/keep -s tag; delete -s tag; qswi"
  222. Xset amiga    "decwrl!pyramid!amiga!support"
  223. Xset header    ~/.mailheader
  224. Xset ask
  225. Xnormal
  226. Xcd ~/Dmail
  227. X---------------------------------------------------------------------------
  228. X
  229. XIn the above example, I have created a Dmail directory to hold all my
  230. Xfolders.  Each folder will be a file containing multiple messages, fully
  231. Xcompatible with /usr/spool/ and mbox.
  232. X
  233. Xmy dmail alias is this:
  234. Xalias dmail '\dmail -O -l ~/Dmail/.dmailrc -o ~/Dmail/mbox -F Cc -F Date'
  235. X
  236. XNOTE: you don't need to alias dmail to anything.  without any arguments,
  237. Xit acts like /bin/Mail getting your mail from your spool, and placing
  238. Xread mail on quit to mbox in your home directory.  I use -O so dmail
  239. Xgives me a command prompt even if there is no mail, and the -F options
  240. Xtell dmail to load those subjects into memory automatically (because I'm
  241. Xgoing to select on them immediately anyway).  If a field which you select
  242. Xon is not in memory, dmail must go to the mail file to find the field.
  243. XThis is transparent.
  244. X
  245. XGOOD LUCK!
  246. X---------------------------------------------- Another example of an .dmailrc
  247. Xif !comlinemail
  248. Xalias ls        "! ls"
  249. Xalias normal    "setlist -s 18 From 38 Subject 10 To 0 Cc 0 Date"
  250. Xalias news        "setlist -s 18 Newsgroup 30 Subject 10 Date 6 Lines 0 Keywords"
  251. Xalias hack        "select To hacker , Cc hacker"
  252. Xalias page        set page more
  253. Xalias nopage    unset page
  254. Xalias spool        "g /usr/spool/mail/dillon ~/Dmail/mbox"
  255. Xalias keep        "g ~/Dmail/keep"
  256. Xalias mbox        "g ~/Dmail/mbox"
  257. Xalias amiga        "select Resent-From: info , To: info , Cc: info
  258. Xalias g         "qswitch"
  259. Xalias kill        "%var sel Sub $var;d all;sel all"
  260. Xset amiga        "decwrl!pyramid!amiga!support"
  261. Xset header        ~/.mailheader
  262. Xnormal
  263. Xcd ~/Dmail
  264. Xset archive        ~/Dmail/arch
  265. Xendif
  266. X-------------------------------------------------------------------
  267. X
  268. X            -Matt
  269. X
  270. X            dillon@ucb-vax.berkeley.edu
  271. X            ...!ucbvax!dillon
  272. X
  273. END_OF_FILE
  274. if test 3002 -ne `wc -c <'uucp2/src/dmail/README'`; then
  275.     echo shar: \"'uucp2/src/dmail/README'\" unpacked with wrong size!
  276. fi
  277. # end of 'uucp2/src/dmail/README'
  278. fi
  279. if test -f 'uucp2/src/dmail/compat.c' -a "${1}" != "-c" ; then 
  280.   echo shar: Will not clobber existing file \"'uucp2/src/dmail/compat.c'\"
  281. else
  282. echo shar: Extracting \"'uucp2/src/dmail/compat.c'\" \(2455 characters\)
  283. sed "s/^X//" >'uucp2/src/dmail/compat.c' <<'END_OF_FILE'
  284. X
  285. X/*
  286. X *  COMPAT.C
  287. X *
  288. X *  $Header: Beta:src/uucp/src/dmail/RCS/compat.c,v 1.1 90/02/02 12:03:31 dillon Exp Locker: dillon $
  289. X *
  290. X *  (C) Copyright 1985-1990 by Matthew Dillon,  All Rights Reserved.
  291. X *
  292. X */
  293. X
  294. X#include <stdio.h>
  295. X#include <pwd.h>
  296. X#include <sys/stat.h>
  297. X#include "config.h"
  298. X
  299. X#ifdef AMIGA
  300. X
  301. Xextern char *gettmpenv();
  302. Xextern char *getenv();
  303. X
  304. X#include <stdlib.h>
  305. X#include <exec/types.h>
  306. X#include <libraries/dos.h>
  307. X#include <libraries/dosextens.h>
  308. X
  309. Xgetpid()
  310. X{
  311. X    return((long)FindTask(NULL));
  312. X}
  313. X
  314. Xgetuid()
  315. X{
  316. X    return(0);
  317. X}
  318. X
  319. Xstatic struct passwd pas;
  320. X
  321. Xstruct passwd *
  322. Xgetpwuid()
  323. X{
  324. X    char *name = gettmpenv("USER");
  325. X    if (name == NULL) {
  326. X    name = FindConfig(USERNAME);
  327. X    if (name == NULL) {
  328. X        puts("Warning, USER enviroment variable not set!");
  329. X        name = "root";
  330. X    }
  331. X    }
  332. X    pas.pw_name = malloc(strlen(name) + 1);
  333. X    pas.pw_dir    = malloc(16);
  334. X    strcpy(pas.pw_name, name);
  335. X    strcpy(pas.pw_dir, "sys:");
  336. X    return(&pas);
  337. X}
  338. X
  339. Xstruct passwd *
  340. Xgetpwnam()
  341. X{
  342. X    return(getpwuid(0));
  343. X}
  344. X
  345. Xvoid
  346. Xbzero(d, n)
  347. Xchar *d;
  348. X{
  349. X    setmem(d, n, 0);
  350. X}
  351. X
  352. Xvoid
  353. Xbcopy(s, d, n)
  354. Xchar *s, *d;
  355. X{
  356. X    movmem(s, d, n);
  357. X}
  358. X
  359. Xvoid
  360. Xsleep(n)
  361. X{
  362. X    if (n)
  363. X    Delay(50 * n);
  364. X}
  365. X
  366. Xstat(file, st)
  367. Xchar *file;
  368. Xstruct stat *st;
  369. X{
  370. X    struct FileLock *lock;
  371. X    struct FileInfoBlock *fib = (struct FileInfoBlock *)malloc(sizeof(struct FileInfoBlock));
  372. X
  373. X    lock = (struct FileLock *)Lock(file, SHARED_LOCK);
  374. X    if (lock == NULL)
  375. X    return(-1);
  376. X    Examine((BPTR)lock, fib);
  377. X    lock = (struct FileLock *)((long)lock << 2);
  378. X    st->st_ino = lock->fl_Key;
  379. X    st->st_ctime = st->st_mtime = fib->fib_Date.ds_Tick / 50 + fib->fib_Date.ds_Minute * 60 + fib->fib_Date.ds_Days * 86400;
  380. X
  381. X    lock = (struct FileLock *)((long)lock >> 2);
  382. X    UnLock((BPTR)lock);
  383. X    free(fib);
  384. X    return(0);
  385. X}
  386. X
  387. Xflock(fd, locktype)
  388. X{
  389. X    return(0);
  390. X}
  391. X
  392. Xchar *
  393. Xgettmpenv(id)
  394. Xchar *id;
  395. X{
  396. X    static char *buf;
  397. X    static char *res = NULL;
  398. X    long fh;
  399. X    long len;
  400. X
  401. X    buf = malloc(strlen(id) + 8);
  402. X    sprintf(buf, "ENV:%s", id);
  403. X    fh = Open(buf, 1005);
  404. X    free(buf);
  405. X    if (fh) {
  406. X    Seek(fh, 0L, 1);
  407. X    len = Seek(fh, 0L, -1);
  408. X    if (len < 0) {
  409. X        Close(fh);
  410. X        return(NULL);
  411. X    }
  412. X    if (res)
  413. X        free(res);
  414. X    res = malloc(len + 1);
  415. X    Read(fh, res, len);
  416. X    Close(fh);
  417. X    res[len] = 0;
  418. X    return(res);
  419. X    }
  420. X    return(NULL);
  421. X}
  422. X
  423. X
  424. Xchar *
  425. Xgetenv(id)
  426. Xconst char *id;
  427. X{
  428. X    char *res = gettmpenv(id);
  429. X    char *perm = NULL;
  430. X
  431. X    if (res) {
  432. X    perm = malloc(strlen(res) + 1);
  433. X    strcpy(perm, res);
  434. X    }
  435. X    return(perm);
  436. X}
  437. X
  438. X#endif
  439. X
  440. END_OF_FILE
  441. if test 2455 -ne `wc -c <'uucp2/src/dmail/compat.c'`; then
  442.     echo shar: \"'uucp2/src/dmail/compat.c'\" unpacked with wrong size!
  443. fi
  444. # end of 'uucp2/src/dmail/compat.c'
  445. fi
  446. if test -f 'uucp2/src/dmail/dmail.h' -a "${1}" != "-c" ; then 
  447.   echo shar: Will not clobber existing file \"'uucp2/src/dmail/dmail.h'\"
  448. else
  449. echo shar: Extracting \"'uucp2/src/dmail/dmail.h'\" \(2728 characters\)
  450. sed "s/^X//" >'uucp2/src/dmail/dmail.h' <<'END_OF_FILE'
  451. X
  452. X/*
  453. X * DMAIL.H
  454. X *
  455. X *  $Header: Beta:src/uucp/src/dmail/RCS/dmail.h,v 1.1 90/02/02 12:03:48 dillon Exp Locker: dillon $
  456. X *
  457. X *  (C) Copyright 1985-1990 by Matthew Dillon,  All Rights Reserved.
  458. X *
  459. X */
  460. X
  461. X#define DVERSION     "Dmail Version 1.12,  June 1989"
  462. X#define MAXTYPE      16     /* Max number of different fields remembered     */
  463. X#define EXSTART      3        /* Beginning of dynamic fields, rest are wired   */
  464. X#define MAXLIST      16     /* Maximum # list elements in SETLIST         */
  465. X#define LONGSTACK    64     /* Maximum # levels for the longjump stack         */
  466. X#define MAILMODE     0600   /* Standard mail mode for temp. files         */
  467. X#define MAXFIELDSIZE 4096   /* Maximum handlable field size (& scratch bufs) */
  468. X
  469. X#define LEVEL_SET    0        /* which variable set to use             */
  470. X#define LEVEL_ALIAS  1
  471. X#define LEVEL_MALIAS 2
  472. X
  473. X#define R_INCLUDE   1        /* Include message        For DO_REPLY()  */
  474. X#define R_FORWARD   2        /* Forward message        */
  475. X#define R_REPLY     3        /* Reply to message     */
  476. X#define R_MAIL        4        /* Mail from scratch    */
  477. X
  478. X#define M_RESET     0
  479. X#define M_CONT        1
  480. X
  481. X
  482. X#define PAGER(Puf)      _pager(Puf, 1)      /* Auto newline */
  483. X#define FPAGER(Puf)     _pager(Puf, 0)      /* output as is */
  484. X#define push_base()     (setjmp (env[1 + Longstack]) ? 1 : (++Longstack, 0))
  485. X#define pop_base()      --Longstack
  486. X#define push_break()    ++Breakstack
  487. X#define pop_break()     --Breakstack
  488. X
  489. X#define ST_DELETED  0x0001  /* Status flag.. item has been deleted  */
  490. X#define ST_READ     0x0002  /* item has been read or marked        */
  491. X#define ST_STORED   0x0010  /* item has been written            */
  492. X#define ST_TAG        0x0020  /* item has been taged            */
  493. X#define ST_SCR        0x0080  /* scratch flag to single out messages  */
  494. X
  495. X#include <stdio.h>
  496. X#include <setjmp.h>
  497. X
  498. Xstruct ENTRY {
  499. X    long fpos;
  500. X    int  no;
  501. X    int  status;
  502. X    char *from;
  503. X    char *fields[MAXTYPE];
  504. X};
  505. X
  506. Xstatic struct FIND {
  507. X    char *search;
  508. X    int  len;
  509. X    int  notnew;
  510. X    int  age;
  511. X};
  512. X
  513. Xextern char *getenv(), *malloc(), *realloc(), *next_word(), *get_field();
  514. Xextern char *alloca();
  515. Xextern char *get_var();
  516. X
  517. Xextern char *mail_file;
  518. Xextern char *user_name;
  519. Xextern char *output_file;
  520. Xextern char *home_dir;
  521. Xextern char *visual;
  522. Xextern char Buf[];
  523. Xextern char Puf[];
  524. Xextern char *av[], *Nulav[3];
  525. Xextern int  Longstack, Breakstack;
  526. Xextern int  XDebug;
  527. Xextern int  Entries, Current;
  528. Xextern int  Silence;
  529. Xextern int  ac;
  530. Xextern FILE *m_fi;
  531. Xextern struct ENTRY *Entry;
  532. Xextern struct FIND  Find[];
  533. Xextern jmp_buf env[];
  534. X
  535. Xextern int width[], header[], Listsize;
  536. Xextern int No_load_mail, XDisable, Did_cd;
  537. Xextern int SelAll;
  538. X
  539. Xextern char *S_sendmail;
  540. Xextern int S_page, S_novibreak, S_verbose, S_ask, S_archive;
  541. Xextern int lmessage_overide;
  542. X
  543. X
  544. END_OF_FILE
  545. if test 2728 -ne `wc -c <'uucp2/src/dmail/dmail.h'`; then
  546.     echo shar: \"'uucp2/src/dmail/dmail.h'\" unpacked with wrong size!
  547. fi
  548. # end of 'uucp2/src/dmail/dmail.h'
  549. fi
  550. if test -f 'uucp2/src/dmail/help.c' -a "${1}" != "-c" ; then 
  551.   echo shar: Will not clobber existing file \"'uucp2/src/dmail/help.c'\"
  552. else
  553. echo shar: Extracting \"'uucp2/src/dmail/help.c'\" \(2676 characters\)
  554. sed "s/^X//" >'uucp2/src/dmail/help.c' <<'END_OF_FILE'
  555. X
  556. X/*
  557. X * HELP.C
  558. X *
  559. X *  $Header: Beta:src/uucp/src/dmail/RCS/help.c,v 1.1 90/02/02 12:04:12 dillon Exp Locker: dillon $
  560. X *
  561. X *  (C) Copyright 1985-1990 by Matthew Dillon,  All Rights Reserved.
  562. X *
  563. X *  Global Routines:    DO_HELP()
  564. X *
  565. X */
  566. X
  567. X#include <stdio.h>
  568. X#include "dmail.h"
  569. X#include "execom.h"
  570. X#include <config.h>
  571. X
  572. X#ifdef AMIGA
  573. X#define HELPFILE "dmail.help"
  574. X#endif
  575. X
  576. X#ifndef HELPFILE
  577. Xstatic char *help[] = {
  578. X#include ".dmkout"
  579. X};
  580. X
  581. Xdo_help()
  582. X{
  583. X    int i, j;
  584. X    char *ptr;
  585. X
  586. X    if (push_base()) {
  587. X    push_break();
  588. X    pop_base();
  589. X    PAGER (-1);
  590. X    pop_break();
  591. X    return;
  592. X    }
  593. X    PAGER (0);
  594. X    if (ac == 1) {
  595. X    for (j = 0; help[j] && *help[j] != '.'; ++j)
  596. X        PAGER (help[j]);
  597. X    for (i = 0; Command[i].name != NULL; ++i) {
  598. X        if (*Command[i].name && !(Command[i].stat & C_NO)) {
  599. X        if (Desc[i] == NULL)
  600. X            puts("Software error, premature EOF in description table");
  601. X        sprintf (Puf, "%-10s %s", Command[i].name, Desc[i]);
  602. X        PAGER (Puf);
  603. X        }
  604. X    }
  605. X    }
  606. X    PAGER ("");
  607. X    for (i = 1; i < ac; ++i) {
  608. X    j = 0;
  609. Xagain:
  610. X    while (help[j]  &&  *help[j] != '.')
  611. X        ++j;
  612. X    if (help[j]) {
  613. X        if (strncmp (av[i], help[j] + 1, strlen(av[i]))) {
  614. X        ++j;
  615. X        goto again;
  616. X        }
  617. X        while (help[j]  &&  *help[j] == '.')
  618. X        ++j;
  619. X        while (help[j]  &&  *help[j] != '.')
  620. X        PAGER (help[j++]);
  621. X        PAGER ("");
  622. X        goto again;
  623. X    }
  624. X    }
  625. X    PAGER (-1);
  626. X    pop_base();
  627. X}
  628. X
  629. X#else
  630. X
  631. Xdo_help()
  632. X{
  633. X    int i;
  634. X    FILE *fi = NULL;
  635. X    char *eof;
  636. X
  637. X    if (push_base()) {
  638. X    push_break();
  639. X    pop_base();
  640. X    PAGER (-1);
  641. X    if (fi != NULL) {
  642. X        fclose (fi);
  643. X        fi = NULL;
  644. X    }
  645. X    pop_break();
  646. X    return (-1);
  647. X    }
  648. X#ifdef AMIGA
  649. X    fi = fopen (MakeConfigPath(UUMAN, HELPFILE), "r");
  650. X#else
  651. X    fi = fopen (HELPFILE, "r");
  652. X#endif
  653. X    if (fi == NULL) {
  654. X    printf ("Cannot open help file: %s\n", HELPFILE);
  655. X    PAGER (-1);
  656. X    pop_base();
  657. X    return (-1);
  658. X    }
  659. X    PAGER (0);
  660. X    if (ac == 1) {
  661. X    while (fgets (Puf, MAXFIELDSIZE, fi)  &&  *Puf != '.')
  662. X        FPAGER (Puf);
  663. X    fclose (fi);
  664. X    fi = NULL;
  665. X    for (i = 0; Command[i].name != NULL; ++i) {
  666. X        if (*Command[i].name) {
  667. X        sprintf (Puf, "%-10s %s", Command[i].name, Desc[i]);
  668. X        PAGER (Puf);
  669. X        }
  670. X    }
  671. X    PAGER (-1);
  672. X    pop_base();
  673. X    return (1);
  674. X    }
  675. X    PAGER ("");
  676. X    for (i = 1; i < ac; ++i) {
  677. X    fseek (fi, 0, 0);
  678. Xagain:
  679. X    while ((eof = fgets (Puf, MAXFIELDSIZE, fi))  &&  *Puf != '.');
  680. X    if (!eof)
  681. X        continue;
  682. X    if (strncmp (av[i], Puf + 1, strlen(av[i])))
  683. X        goto again;
  684. X    while ((eof = fgets (Puf, MAXFIELDSIZE, fi))  &&  *Puf == '.');
  685. X    if (!eof)
  686. X        continue;
  687. X    FPAGER (Puf);
  688. X    while ((eof = fgets (Puf, MAXFIELDSIZE, fi))  &&  *Puf != '.')
  689. X        FPAGER (Puf);
  690. X    PAGER ("");
  691. X    if (!eof)
  692. X        continue;
  693. X    goto again;
  694. X    }
  695. X    fclose (fi);
  696. X    fi = NULL;
  697. X    PAGER (-1);
  698. X    pop_base();
  699. X}
  700. X
  701. X#endif
  702. X
  703. END_OF_FILE
  704. if test 2676 -ne `wc -c <'uucp2/src/dmail/help.c'`; then
  705.     echo shar: \"'uucp2/src/dmail/help.c'\" unpacked with wrong size!
  706. fi
  707. # end of 'uucp2/src/dmail/help.c'
  708. fi
  709. if test -f 'uucp2/src/dmail/set.c' -a "${1}" != "-c" ; then 
  710.   echo shar: Will not clobber existing file \"'uucp2/src/dmail/set.c'\"
  711. else
  712. echo shar: Extracting \"'uucp2/src/dmail/set.c'\" \(2818 characters\)
  713. sed "s/^X//" >'uucp2/src/dmail/set.c' <<'END_OF_FILE'
  714. X
  715. X/*
  716. X *  SET.C
  717. X *
  718. X *  $Header: Beta:src/uucp/src/dmail/RCS/set.c,v 1.1 90/02/02 12:04:15 dillon Exp Locker: dillon $
  719. X *
  720. X *  (C) Copyright 1985-1990 by Matthew Dillon,  All Rights Reserved.
  721. X *
  722. X *  Variable set/unset/get/reset routines
  723. X *
  724. X */
  725. X
  726. X
  727. X#include <stdio.h>
  728. X#include "dmail.h"
  729. X#define MAXLEVELS 3
  730. X
  731. Xstruct MASTER {
  732. X    struct MASTER *next;
  733. X    struct MASTER *last;
  734. X    char *name;
  735. X    char *text;
  736. X};
  737. X
  738. Xstruct MASTER *Mbase[MAXLEVELS];
  739. X
  740. Xvoid
  741. Xset_var (level, name, str)
  742. Xregister char *name, *str;
  743. X{
  744. X    register struct MASTER *base = Mbase[level];
  745. X    register struct MASTER *last;
  746. X
  747. X    push_break();
  748. X    while (base != NULL) {
  749. X    if (strcmp (name, base->name) == 0) {
  750. X        xfree (base->text);
  751. X        goto gotit;
  752. X    }
  753. X    last = base;
  754. X    base = base->next;
  755. X    }
  756. X    if (base == Mbase[level]) {
  757. X    base = Mbase[level] = (struct MASTER *)malloc (sizeof (struct MASTER));
  758. X    base->last = NULL;
  759. X    } else {
  760. X    base = (struct MASTER *)malloc (sizeof (struct MASTER));
  761. X    base->last = last;
  762. X    last->next = base;
  763. X    }
  764. X    base->name = malloc (strlen (name) + 1);
  765. X    strcpy (base->name, name);
  766. X    base->next = NULL;
  767. Xgotit:
  768. X    base->text    = malloc (strlen (str) + 1);
  769. X    strcpy (base->text, str);
  770. X    pop_break();
  771. X}
  772. X
  773. X
  774. Xunset_var(level, name)
  775. Xregister char *name;
  776. X{
  777. X    register struct MASTER *base = Mbase[level];
  778. X    register struct MASTER *last = NULL;
  779. X
  780. X    push_break();
  781. X    while (base != NULL) {
  782. X    if (strcmp (name, base->name) == 0) {
  783. X        if (base != Mbase[level])
  784. X        last->next = base->next;
  785. X        else
  786. X        Mbase[level] = base->next;
  787. X        if (base->next != NULL)
  788. X        base->next->last = last;
  789. X        if (base == Mbase[level])
  790. X        Mbase[level] = base->next;
  791. X        xfree (base->name);
  792. X        xfree (base->text);
  793. X        xfree (base);
  794. X        pop_break();
  795. X        return (1);
  796. X    }
  797. X    last = base;
  798. X    base = base->next;
  799. X    }
  800. X    pop_break();
  801. X    return (-1);
  802. X}
  803. X
  804. X
  805. Xchar *
  806. Xget_var(level, name)
  807. Xregister char *name;
  808. X{
  809. X    register struct MASTER *base = Mbase[level];
  810. X
  811. X    while (base != NULL) {
  812. X    if (strcmp (name, base->name) == 0)
  813. X        return (base->text);
  814. X    base = base->next;
  815. X    }
  816. X    return (NULL);
  817. X}
  818. X
  819. X
  820. Xdo_unset_var(str, level)
  821. Xchar *str;
  822. X{
  823. X    int i;
  824. X
  825. X    push_break();
  826. X    for (i = 1; i < ac; ++i)
  827. X    unset_var (level, av[i]);
  828. X    fix_globals();
  829. X    pop_break();
  830. X    return (1);
  831. X}
  832. X
  833. Xvoid
  834. Xdo_set_var(command, level)
  835. Xchar *command;
  836. X{
  837. X    register struct MASTER *base = Mbase[level];
  838. X    register char *str;
  839. X
  840. X    if (ac == 1) {
  841. X    while (base) {
  842. X        printf ("%-10s %s\n", base->name, base->text);
  843. X        base = base->next;
  844. X    }
  845. X    }
  846. X    if (ac == 2) {
  847. X    str = get_var (level, av[1]);
  848. X    if (str) {
  849. X        printf ("%-10s %s\n", av[1], str);
  850. X    } else {
  851. X        push_break();
  852. X        set_var (level, av[1], "");
  853. X        fix_globals();
  854. X        pop_break();
  855. X    }
  856. X    }
  857. X    if (ac > 2) {
  858. X    push_break();
  859. X    set_var (level, av[1], next_word (next_word (command)));
  860. X    fix_globals();
  861. X    pop_break();
  862. X    }
  863. X}
  864. X
  865. X
  866. X
  867. END_OF_FILE
  868. if test 2818 -ne `wc -c <'uucp2/src/dmail/set.c'`; then
  869.     echo shar: \"'uucp2/src/dmail/set.c'\" unpacked with wrong size!
  870. fi
  871. # end of 'uucp2/src/dmail/set.c'
  872. fi
  873. if test -f 'uucp2/src/include/config.h' -a "${1}" != "-c" ; then 
  874.   echo shar: Will not clobber existing file \"'uucp2/src/include/config.h'\"
  875. else
  876. echo shar: Extracting \"'uucp2/src/include/config.h'\" \(2546 characters\)
  877. sed "s/^X//" >'uucp2/src/include/config.h' <<'END_OF_FILE'
  878. X
  879. X/*
  880. X *  CONFIG.H
  881. X *
  882. X *  $Header: Beta:src/uucp/src/include/RCS/config.h,v 1.1 90/02/02 11:35:03 dillon Exp Locker: dillon $
  883. X */
  884. X
  885. X#ifndef _CONFIG_H
  886. X#define _CONFIG_H
  887. X
  888. X#ifndef _NDIR_H
  889. X#include "ndir.h"
  890. X#endif
  891. X#ifndef _GETFILES_H
  892. X#include "getfiles.h"
  893. X#endif
  894. X
  895. X#define Prototype   extern
  896. X#define Local
  897. X#define ProtoInclude
  898. X
  899. X#include "lib_protos.h"     /*  MACHINE GENERATED   */
  900. X
  901. X#define USERNAME    "UserName"
  902. X#define NODENAME    "NodeName"
  903. X#define REALNAME    "RealName"
  904. X#define DEBUGNAME    "Debug"
  905. X#define NEWSFEED    "NewsFeed"
  906. X#define ORGANIZATION    "Organization"
  907. X#define FILTER        "Filter"        /*  can be run in the foregnd    */
  908. X#define RFILTER     "RFilter"       /*  can be run in the background */
  909. X#define EDITOR        "MailEditor"
  910. X#define NEWSEDITOR    "NewsEditor"
  911. X#define HOME        "Home"
  912. X#define DOMAINNAME    "DomainName"
  913. X#define MAILREADYCMD    "MailReadyCmd"
  914. X#define NEWSREADYCMD    "NewsReadyCmd"
  915. X
  916. X/*
  917. X *  The following config entries are self-defaults... if the config
  918. X *  entry does not exist the default is the config-name.  The config
  919. X *  entry is normally retrieve with 'GetConfigProgram(string)'
  920. X */
  921. X
  922. X#define UUX        "Uux"
  923. X#define SENDMAIL    "Sendmail"
  924. X#define POSTNEWS    "Postnews"
  925. X#define UUXQT        "Uuxqt"
  926. X#define RMAIL        "RMail"
  927. X#define CUNBATCH    "CUnbatch"
  928. X#define RNEWS        "RNews"
  929. X
  930. X#define RNEWSDEBUG    "RNewsDebug"
  931. X
  932. X/*
  933. X *  The following config entries are directory-defaults... if the
  934. X *  config entry does not exist the specified default is returned.
  935. X *
  936. X *  These entries are retrieved via 'GetConfigDir(string)'
  937. X *
  938. X *  The SUUCP entry is used ONLY by people doing distributions and
  939. X *  working on the source.
  940. X */
  941. X
  942. X#define UUSPOOL     "UUSpool\0UUSPOOL:"
  943. X#define UUNEWS        "UUNews\0UUNEWS:"
  944. X#define UUMAIL        "UUMail\0UUMAIL:"
  945. X#define UULIB        "UULib\0UULIB:"
  946. X#define UUPUB        "UUPub\0UUPUB:"
  947. X#define UUMAN        "UUMan\0UUMAN:"
  948. X#define SUUCP        "UUCP\0UUCP:"
  949. X#define UUALTSPOOL  "UUAltSpool\0UUALTSPOOL:"
  950. X
  951. X/*
  952. X * This idea (and base) for this code was written by Fred Cassirer 10/9/88
  953. X * as a Config file for News programs, to whom I say Thanx!
  954. X *
  955. X * It has since been expanded to include all the directory paths and some
  956. X * command/filenames. This is to eliminate the forced use of hardcoding in
  957. X * the executables.
  958. X *
  959. X * Simply change any of these you may need to, and recompile as needed.
  960. X *
  961. X * Sneakers 11/21/88
  962. X *
  963. X */
  964. X
  965. X#define MAXGROUPS 1024    /* Maximum # of subscribed newsgroups */
  966. X#define MAXFILES  1000    /* Max # of files in any news or spool directory */
  967. X
  968. X/*
  969. X *  overrides any previous NULL
  970. X */
  971. X
  972. X#ifdef NULL
  973. X#undef NULL
  974. X#endif
  975. X#define NULL ((void *)0L)
  976. X
  977. X#endif
  978. X
  979. END_OF_FILE
  980. if test 2546 -ne `wc -c <'uucp2/src/include/config.h'`; then
  981.     echo shar: \"'uucp2/src/include/config.h'\" unpacked with wrong size!
  982. fi
  983. # end of 'uucp2/src/include/config.h'
  984. fi
  985. if test -f 'uucp2/src/include/lib_protos.h' -a "${1}" != "-c" ; then 
  986.   echo shar: Will not clobber existing file \"'uucp2/src/include/lib_protos.h'\"
  987. else
  988. echo shar: Extracting \"'uucp2/src/include/lib_protos.h'\" \(2369 characters\)
  989. sed "s/^X//" >'uucp2/src/include/lib_protos.h' <<'END_OF_FILE'
  990. X
  991. X/* MACHINE GENERATED */
  992. X
  993. X
  994. X/* getpwnam.c           */
  995. X
  996. XPrototype struct passwd *getpwnam(const char *);
  997. X
  998. X/* serialport.c         */
  999. X
  1000. XPrototype void LockSerialPort(const char *, long);
  1001. XPrototype void UnLockSerialPort(const char *, long);
  1002. X
  1003. X/* setstdin.c           */
  1004. X
  1005. XPrototype int SetStdin(int, char **);
  1006. X
  1007. X/* sleep.c              */
  1008. X
  1009. XPrototype void sleep(int);
  1010. X
  1011. X/* validuser.c          */
  1012. X
  1013. XPrototype int ValidUser(const char *);
  1014. X
  1015. X/* lsys.c               */
  1016. X
  1017. XPrototype int is_in_L_sys_file(const char *);
  1018. X
  1019. X/* mntreq.c             */
  1020. X
  1021. XPrototype void mountrequest(int);
  1022. X
  1023. X/* security.c           */
  1024. X
  1025. XPrototype int SecurityDisallow(char *, int);
  1026. XPrototype int SameLock(long, long);
  1027. X
  1028. X/* log.c                */
  1029. X
  1030. XPrototype void ulog(int, const char *, ...);
  1031. X
  1032. X/* lockfile.c           */
  1033. X
  1034. XPrototype void LockFile(const char *);
  1035. XPrototype void UnLockFile(const char *);
  1036. XPrototype void UnLockFiles(void);
  1037. X
  1038. X/* tmpfile.c            */
  1039. X
  1040. XPrototype char *TmpFileName(const char *);
  1041. X
  1042. X/* seq.c                */
  1043. X
  1044. XPrototype int GetSequence(int);
  1045. X
  1046. X/* getenv.c             */
  1047. X
  1048. XPrototype char *gettmpenv(const char *);
  1049. XPrototype char *getenv(const char *);
  1050. X
  1051. X/* config.c             */
  1052. X
  1053. XPrototype char *FindConfig(const char *);
  1054. XPrototype char *GetConfig(const char *, char *);
  1055. XPrototype char *GetConfigDir(char *);
  1056. XPrototype char *GetConfigProgram(char *);
  1057. XPrototype char *MakeConfigPath(const char *, const char *);
  1058. XPrototype char *MallocEnviro(const char *);
  1059. XPrototype FILE *openlib(const char *);
  1060. XPrototype FILE *openlib_write(const char *);
  1061. X
  1062. X/* alias.c              */
  1063. X
  1064. XPrototype void LoadAliases(void);
  1065. XPrototype void UserAliasList(const char *, void (*)(const char *));
  1066. X
  1067. X/* string.c             */
  1068. X
  1069. XPrototype int strcmpi(const char *, const char *);
  1070. XPrototype int strncmpi(const char *, const char *, int);
  1071. X
  1072. X/* getfiles.c           */
  1073. X
  1074. XPrototype dir_list *getfiles(const char *, int, int (*)(char *), int (*)(dir_list *, dir_list *));
  1075. X
  1076. X/* ndir.c               */
  1077. X
  1078. XPrototype DIR *opendir(const char *);
  1079. XPrototype void rewinddir(DIR *);
  1080. XPrototype struct direct *readdir(DIR *);
  1081. XPrototype void closedir(DIR *);
  1082. X
  1083. X/* list_sort.c          */
  1084. X
  1085. X
  1086. X/* expand_path.c        */
  1087. X
  1088. XPrototype char *expand_path(const char *, const char *);
  1089. X
  1090. X/* isdir.c              */
  1091. X
  1092. XPrototype int IsDir(const char *);
  1093. X
  1094. X/* getuser.c            */
  1095. X
  1096. XPrototype char *GetUserName(void);
  1097. XPrototype char *GetRealName(void);
  1098. END_OF_FILE
  1099. if test 2369 -ne `wc -c <'uucp2/src/include/lib_protos.h'`; then
  1100.     echo shar: \"'uucp2/src/include/lib_protos.h'\" unpacked with wrong size!
  1101. fi
  1102. # end of 'uucp2/src/include/lib_protos.h'
  1103. fi
  1104. if test -f 'uucp2/src/include/uucico_protos.h' -a "${1}" != "-c" ; then 
  1105.   echo shar: Will not clobber existing file \"'uucp2/src/include/uucico_protos.h'\"
  1106. else
  1107. echo shar: Extracting \"'uucp2/src/include/uucico_protos.h'\" \(2326 characters\)
  1108. sed "s/^X//" >'uucp2/src/include/uucico_protos.h' <<'END_OF_FILE'
  1109. X
  1110. X/* MACHINE GENERATED */
  1111. X
  1112. X
  1113. X/* gio.c                */
  1114. X
  1115. XPrototype int gwrdata(FILE *);
  1116. XPrototype int gwrmsg(char *);
  1117. XPrototype int grddata(FILE *);
  1118. XPrototype int grdmsg(char *, int);
  1119. XPrototype int gturnon(int);
  1120. XPrototype int gturnoff(void);
  1121. XPrototype void ResetGIO(void);
  1122. X
  1123. X/* sysdep.c             */
  1124. X
  1125. XPrototype int openout(char *, int);
  1126. XPrototype int sigint(void);
  1127. XPrototype void cleanup(void);
  1128. XPrototype int xdatardy(void);
  1129. XPrototype int xgetc(int);
  1130. XPrototype int xwrite(const void *, int);
  1131. XPrototype int xwritea(const void *, int);
  1132. XPrototype int xxwrite(const void *, int, int);
  1133. XPrototype void SendBreak(void);
  1134. XPrototype int CheckCarrier(void);
  1135. XPrototype void *bzero(void *, long);
  1136. XPrototype void *bcopy(const void *, void *, long);
  1137. XPrototype void munge_filename(char *, char *);
  1138. XPrototype int hangup(void);
  1139. XPrototype char *work_scan(char *);
  1140. XPrototype char *work_next(void);
  1141. XPrototype void amiga_closeopen(char *);
  1142. XPrototype void amiga_setup(void);
  1143. XPrototype void set_baud(int);
  1144. XPrototype void OpenSerial(void);
  1145. XPrototype void CloseSerial(void);
  1146. XPrototype void xexit(int);
  1147. XPrototype void printc(unsigned char);
  1148. X
  1149. X/* uucp.c               */
  1150. X
  1151. X
  1152. X/* uupoll.c             */
  1153. X
  1154. X
  1155. X/* uuxqt.c              */
  1156. X
  1157. X
  1158. X/* modem.c              */
  1159. X
  1160. XPrototype void openline(void);
  1161. XPrototype int  get_baud(void);
  1162. XPrototype void modem_init(void);
  1163. XPrototype int  dial_nbr(const char *);
  1164. XPrototype void reset_modem(void);
  1165. X
  1166. X/* uucico.c             */
  1167. X
  1168. XPrototype   int getname(int);
  1169. XPrototype   int get_proto(void);
  1170. XPrototype   int instr(char *, int);
  1171. XPrototype   int twrite(const char *, int);
  1172. XPrototype   void xlat_str(char *, char *);
  1173. XPrototype   int read_ctl(void);
  1174. XPrototype   int do_outbound(void);
  1175. XPrototype   int call_system(char *, int);
  1176. XPrototype   int call_sysline(char *);
  1177. XPrototype   int do_session(int);
  1178. XPrototype   int top_level(int);
  1179. XPrototype   int do_one_slave(void);
  1180. XPrototype   int do_one_master(void);
  1181. XPrototype   int yesno(char, int, int);
  1182. XPrototype   int host_send_file(char *);
  1183. XPrototype   int host_receive_file(char *);
  1184. XPrototype   int local_send_file(char *, int *);
  1185. XPrototype   int local_receive_file(void);
  1186. XPrototype   int receive_file(FILE *, char *, char *, char *, int);
  1187. XPrototype   int send_file(FILE *);
  1188. X
  1189. X/* uuhosts.c            */
  1190. X
  1191. X
  1192. X/* uuname.c             */
  1193. X
  1194. X
  1195. X/* uux.c                */
  1196. X
  1197. X
  1198. X/* time.c               */
  1199. X
  1200. END_OF_FILE
  1201. if test 2326 -ne `wc -c <'uucp2/src/include/uucico_protos.h'`; then
  1202.     echo shar: \"'uucp2/src/include/uucico_protos.h'\" unpacked with wrong size!
  1203. fi
  1204. # end of 'uucp2/src/include/uucico_protos.h'
  1205. fi
  1206. if test -f 'uucp2/src/lib/lockfile.c' -a "${1}" != "-c" ; then 
  1207.   echo shar: Will not clobber existing file \"'uucp2/src/lib/lockfile.c'\"
  1208. else
  1209. echo shar: Extracting \"'uucp2/src/lib/lockfile.c'\" \(2626 characters\)
  1210. sed "s/^X//" >'uucp2/src/lib/lockfile.c' <<'END_OF_FILE'
  1211. X
  1212. X/*
  1213. X *  LOCKFILE.C
  1214. X *
  1215. X *  $Header: Beta:src/uucp/src/lib/RCS/lockfile.c,v 1.1 90/02/02 12:08:31 dillon Exp Locker: dillon $
  1216. X *
  1217. X *  (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  1218. X *
  1219. X *  Lock and unlock a file.  Under AmigaDOS, openning a file mode 1006
  1220. X *  (accomplished with fopen(,"w"), locks the file exclusively.  That
  1221. X *  is, further fopen()s will fail.  Thus, we need only keep a live
  1222. X *  file descriptor to 'lock' the file.
  1223. X *
  1224. X *  This is advantagious because if the program exits without removing
  1225. X *  the lock file we are still ok... the file is unlocked by virtue of
  1226. X *  the file descriptor getting closed.
  1227. X */
  1228. X
  1229. X#include <exec/types.h>
  1230. X#include <exec/lists.h>
  1231. X#include "protos.h"
  1232. X#include <stdio.h>
  1233. X#include <stdlib.h>
  1234. X#include "config.h"
  1235. X
  1236. Xtypedef struct List LIST;
  1237. Xtypedef struct Node NODE;
  1238. X
  1239. Xtypedef struct {
  1240. X    NODE    Node;
  1241. X    FILE    *Fi;
  1242. X    short   Refs;
  1243. X} LNode;
  1244. X
  1245. XPrototype void LockFile(const char *);
  1246. XPrototype void UnLockFile(const char *);
  1247. XPrototype void UnLockFiles(void);
  1248. XLocal void FreeLockNode(LNode *);
  1249. X
  1250. XLIST LockList = { (NODE *)&LockList.lh_Tail, NULL, (NODE *)&LockList.lh_Head };
  1251. X
  1252. X
  1253. Xvoid
  1254. XLockFile(file)
  1255. Xconst char *file;
  1256. X{
  1257. X    const char *ptr;
  1258. X
  1259. X    LNode *node;
  1260. X    LNode *n;
  1261. X
  1262. X    for (ptr = file + strlen(file); ptr >= file && *ptr != '/' && *ptr != ':'; --ptr);
  1263. X    ++ptr;
  1264. X
  1265. X
  1266. X    if (node = malloc(sizeof(LNode) + strlen(ptr) + 16)) {
  1267. X    node->Node.ln_Name = (char *)(node + 1);
  1268. X    sprintf(node->Node.ln_Name, "T:%s.LOCK", ptr);
  1269. X
  1270. X    for (n = (LNode *)LockList.lh_Head; n != (LNode *)&LockList.lh_Tail; n = (LNode *)n->Node.ln_Succ) {
  1271. X        if (strcmp(node->Node.ln_Name, n->Node.ln_Name) == 0) {
  1272. X        ++n->Refs;
  1273. X        free(node);
  1274. X        return;
  1275. X        }
  1276. X    }
  1277. X
  1278. X    while ((node->Fi = fopen(node->Node.ln_Name, "w")) == NULL) {
  1279. X        sleep(2);
  1280. X        chkabort();
  1281. X    }
  1282. X    node->Refs = 1;
  1283. X    AddTail(&LockList, &node->Node);
  1284. X    }
  1285. X}
  1286. X
  1287. Xvoid
  1288. XUnLockFile(file)
  1289. Xconst char *file;
  1290. X{
  1291. X    LNode *node;
  1292. X    short len;
  1293. X    const char *ptr;
  1294. X
  1295. X    for (ptr = file + strlen(file); ptr >= file && *ptr != '/' && *ptr != ':'; --ptr);
  1296. X    ++ptr;
  1297. X    len = strlen(ptr);
  1298. X
  1299. X    for (node = (LNode *)LockList.lh_Head; node != (LNode *)&LockList.lh_Tail; node = (LNode *)node->Node.ln_Succ) {
  1300. X    if (strncmp(ptr, node->Node.ln_Name + 2, len) == 0 && strlen(node->Node.ln_Name) == len + 7) {
  1301. X        if (--node->Refs == 0)
  1302. X        FreeLockNode(node);
  1303. X        return;
  1304. X    }
  1305. X    }
  1306. X}
  1307. X
  1308. Xvoid
  1309. XUnLockFiles()
  1310. X{
  1311. X    LNode *node;
  1312. X
  1313. X    while ((node = (LNode *)LockList.lh_Head) != (LNode *)&LockList.lh_Tail)
  1314. X    FreeLockNode(node);
  1315. X}
  1316. X
  1317. Xstatic void
  1318. XFreeLockNode(node)
  1319. XLNode *node;
  1320. X{
  1321. X    Remove(node);
  1322. X    fclose(node->Fi);
  1323. X    unlink(node->Node.ln_Name);
  1324. X    free(node);
  1325. X}
  1326. X
  1327. END_OF_FILE
  1328. if test 2626 -ne `wc -c <'uucp2/src/lib/lockfile.c'`; then
  1329.     echo shar: \"'uucp2/src/lib/lockfile.c'\" unpacked with wrong size!
  1330. fi
  1331. # end of 'uucp2/src/lib/lockfile.c'
  1332. fi
  1333. if test -f 'uucp2/src/lib/ndir.c' -a "${1}" != "-c" ; then 
  1334.   echo shar: Will not clobber existing file \"'uucp2/src/lib/ndir.c'\"
  1335. else
  1336. echo shar: Extracting \"'uucp2/src/lib/ndir.c'\" \(2498 characters\)
  1337. sed "s/^X//" >'uucp2/src/lib/ndir.c' <<'END_OF_FILE'
  1338. X
  1339. X/*
  1340. X *  NDIR.C
  1341. X *
  1342. X *  Amiga (Lattice & Manx) "ndir" Library
  1343. X */
  1344. X
  1345. X#include <exec/types.h>
  1346. X#include <exec/memory.h>
  1347. X#include <libraries/dosextens.h>
  1348. X
  1349. X#include <stdio.h>
  1350. X#include <stdlib.h>
  1351. X#include <string.h>
  1352. X
  1353. X#include "ndir.h"
  1354. X#include "protos.h"
  1355. X#include "version.h"
  1356. X
  1357. XIDENT(".01");
  1358. X
  1359. XPrototype DIR *opendir(const char *);
  1360. XPrototype void rewinddir(DIR *);
  1361. XPrototype struct direct *readdir(DIR *);
  1362. XPrototype void closedir(DIR *);
  1363. X
  1364. X/*
  1365. X * open a directory.
  1366. X */
  1367. X
  1368. XDIR *
  1369. Xopendir(const char *name)
  1370. X{
  1371. X    register DIR *dirp;
  1372. X    BPTR lock;
  1373. X
  1374. X#ifdef TEST
  1375. X    fprintf(stderr, "opendir: Opening \"%s\"\n", name);
  1376. X#endif
  1377. X    if ((lock = Lock(name, (long)ACCESS_READ)) == NULL) {
  1378. X#ifdef TEST
  1379. X    fprintf(stderr, "opendir: Can't open.\n");
  1380. X#endif
  1381. X    return NULL;
  1382. X    }
  1383. X    if ((dirp = (DIR *)malloc(sizeof(DIR))) == NULL) {
  1384. X#ifdef TEST
  1385. X    fprintf(stderr, "opendir: couldn't malloc %d\n", sizeof(DIR));
  1386. X#endif
  1387. X    UnLock(lock);
  1388. X    return NULL;
  1389. X    }
  1390. X#ifdef TEST
  1391. X    fprintf(stderr, "FIB location is 0%lo\n", &dirp->fib);
  1392. X#endif
  1393. X    if (!Examine(lock, &dirp->fib)) {
  1394. X#ifdef TEST
  1395. X     fprintf(stderr, "opendir: Couldn't Examine directory\n");
  1396. X#endif
  1397. X     free(dirp);
  1398. X     UnLock(lock);
  1399. X    }
  1400. X    dirp->lock = (long)lock;
  1401. X#ifdef TEST
  1402. X    fputs("opendir: Sucessful\n", stderr);
  1403. X#endif
  1404. X    return dirp;
  1405. X}
  1406. X
  1407. X/*
  1408. X * go back to the begining of the directory
  1409. X */
  1410. X
  1411. Xvoid
  1412. Xrewinddir(DIR *dirp)
  1413. X{
  1414. X    Examine((BPTR)dirp->lock, &dirp->fib);
  1415. X}
  1416. X
  1417. X/*
  1418. X * get next entry in a directory.
  1419. X */
  1420. X
  1421. Xstruct direct *
  1422. Xreaddir(DIR *dirp)
  1423. X{
  1424. X    static struct direct dir;
  1425. X
  1426. X    while (ExNext((BPTR)dirp->lock, &dirp->fib)) {
  1427. X    if (dirp->fib.fib_DirEntryType <= 0) {
  1428. X        dir.d_ino = dirp->fib.fib_DiskKey;
  1429. X        strcpy(dir.d_name, dirp->fib.fib_FileName);
  1430. X#ifdef TEST
  1431. X        fprintf(stderr, "readdir: OK \"%s\"\n",  dir.d_name);
  1432. X#endif
  1433. X        dir.d_namlen = strlen(dir.d_name);
  1434. X        dir.d_reclen = DIRSIZ(&dir);
  1435. X        return &dir;
  1436. X    }
  1437. X    }
  1438. X#ifdef TEST
  1439. X    fprintf(stderr, "readdir: No More Entries.\n");
  1440. X#endif
  1441. X    dir.d_name[0] = '\0';
  1442. X    return NULL;
  1443. X}
  1444. X
  1445. X/*
  1446. X * close a directory.
  1447. X */
  1448. X
  1449. Xvoid
  1450. Xclosedir(DIR *dirp)
  1451. X{
  1452. X    UnLock((BPTR)dirp->lock);
  1453. X    free((char *)dirp);
  1454. X}
  1455. X
  1456. X#ifdef TEST
  1457. X
  1458. Xmain(void)
  1459. X{
  1460. X    char command[100];
  1461. X
  1462. X    DIR *dirp;
  1463. X    struct direct *dp;
  1464. X
  1465. X    while(gets(command) != NULL) {
  1466. X    fprintf(stderr, "test: %s\n", command);
  1467. X    if ((dirp = opendir(command)) == NULL) {
  1468. X        fprintf(stderr, "couldn't open dir %s\n", command);
  1469. X    } else {
  1470. X        while ((dp = readdir(dirp)) != NULL)
  1471. X        fprintf(stderr, "%s\n", dp->d_name);
  1472. X        closedir(dirp);
  1473. X    }
  1474. X    }
  1475. X    return 0;
  1476. X}
  1477. X
  1478. X#endif
  1479. X
  1480. END_OF_FILE
  1481. if test 2498 -ne `wc -c <'uucp2/src/lib/ndir.c'`; then
  1482.     echo shar: \"'uucp2/src/lib/ndir.c'\" unpacked with wrong size!
  1483. fi
  1484. # end of 'uucp2/src/lib/ndir.c'
  1485. fi
  1486. if test -f 'uucp2/src/lib/security.c' -a "${1}" != "-c" ; then 
  1487.   echo shar: Will not clobber existing file \"'uucp2/src/lib/security.c'\"
  1488. else
  1489. echo shar: Extracting \"'uucp2/src/lib/security.c'\" \(2746 characters\)
  1490. sed "s/^X//" >'uucp2/src/lib/security.c' <<'END_OF_FILE'
  1491. X
  1492. X/*
  1493. X *  SECURITY.C
  1494. X *
  1495. X *  $Header: Beta:src/uucp/src/lib/RCS/security.c,v 1.1 90/02/02 12:08:33 dillon Exp Locker: dillon $
  1496. X *
  1497. X *  (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  1498. X *
  1499. X *  Checks whether a given file should be allowed to be read or written
  1500. X *
  1501. X *  Lock directory containing file
  1502. X *  Generate directory path
  1503. X *  Check path against allowed list (UULIB:Security)
  1504. X *
  1505. X *  If type == 'c' return  1 if file name begins with a C.
  1506. X *           return -1 if file name does not begin with a C.
  1507. X *           return  0 if file name begins with a C. but is for
  1508. X *            a directory other than the current one.
  1509. X */
  1510. X
  1511. X#include <exec/types.h>
  1512. X#include <libraries/dosextens.h>
  1513. X#include <stdio.h>
  1514. X#include "config.h"
  1515. X
  1516. Xtypedef struct FileLock FileLock;
  1517. Xtypedef struct Process    Process;
  1518. X
  1519. XPrototype int SecurityDisallow(char *, int);
  1520. XPrototype int SameLock(long, long);
  1521. X
  1522. Xextern void *FindTask();
  1523. X
  1524. Xstatic char TmpBuf[128];
  1525. X
  1526. Xint
  1527. XSecurityDisallow(file, type)
  1528. Xchar *file;
  1529. Xint type;
  1530. X{
  1531. X    char *fs;
  1532. X    char c;
  1533. X    int  disallow = 1;
  1534. X    BPTR lock;
  1535. X    BPTR slock;
  1536. X    Process *proc = (Process *)FindTask(NULL);
  1537. X    APTR oldWindowPtr = proc->pr_WindowPtr;
  1538. X
  1539. X    for (fs = file + strlen(file); fs >= file && *fs != '/' && *fs != ':'; --fs);
  1540. X    ++fs;
  1541. X    if (fs == file) {           /*  just a file name    */
  1542. X    if (type == 'c') {
  1543. X        if ((file[0]|0x20) == 'c' && file[1] == '.')
  1544. X        return(1);
  1545. X        return(-1);
  1546. X    }
  1547. X    return(0);              /*  type r or w, current dir, allow. */
  1548. X    }
  1549. X    if (type == 'c')            /*  not just a file name, allow C.   */
  1550. X    return(0);
  1551. X    c = *fs;
  1552. X    *fs = 0;        /*  keep just the path        */
  1553. X
  1554. X    proc->pr_WindowPtr = (APTR)-1L;
  1555. X    lock = Lock(file, SHARED_LOCK);
  1556. X    if (lock) {
  1557. X    FILE *fi = fopen(MakeConfigPath(UULIB, "Security"), "r");
  1558. X    if (fi) {
  1559. X        while (fgets(TmpBuf, sizeof(TmpBuf), fi)) {
  1560. X        char *ptr;
  1561. X        if (TmpBuf[0] == '#' || TmpBuf[0] == '\n' || TmpBuf[0] == 0)
  1562. X            continue;
  1563. X
  1564. X        /*
  1565. X         *  breakout the directory name and permissions
  1566. X         */
  1567. X
  1568. X        for (ptr = TmpBuf; *ptr != '\n' && *ptr != ' ' && *ptr != 9; ++ptr);
  1569. X        *ptr = 0;
  1570. X
  1571. X        /*
  1572. X         *  permissions allowed?
  1573. X         */
  1574. X
  1575. X        for (++ptr; *ptr && *ptr != type; ++ptr);
  1576. X        if (*ptr == 0)      /*  sorry   */
  1577. X            continue;
  1578. X
  1579. X        if (slock = Lock(TmpBuf, SHARED_LOCK)) {
  1580. X            if (SameLock(lock, slock))
  1581. X            disallow = 0;
  1582. X            UnLock(slock);
  1583. X        }
  1584. X        if (disallow == 0)
  1585. X            break;
  1586. X        }
  1587. X        fclose(fi);
  1588. X    }
  1589. X    UnLock(lock);
  1590. X    }
  1591. X    proc->pr_WindowPtr = oldWindowPtr;
  1592. X
  1593. X    *fs = c;        /*  restore path    */
  1594. X
  1595. X    return(disallow);
  1596. X}
  1597. X
  1598. Xint
  1599. XSameLock(lock, slock)
  1600. Xlong lock, slock;
  1601. X{
  1602. X    FileLock *fl1 = (FileLock *)((long)lock << 2);
  1603. X    FileLock *fl2 = (FileLock *)((long)slock << 2);
  1604. X
  1605. X    if (fl1->fl_Task == fl2->fl_Task && fl1->fl_Key == fl2->fl_Key)
  1606. X    return(1);
  1607. X    return(0);
  1608. X}
  1609. X
  1610. END_OF_FILE
  1611. if test 2746 -ne `wc -c <'uucp2/src/lib/security.c'`; then
  1612.     echo shar: \"'uucp2/src/lib/security.c'\" unpacked with wrong size!
  1613. fi
  1614. # end of 'uucp2/src/lib/security.c'
  1615. fi
  1616. if test -f 'uucp2/src/lib/serialport.c' -a "${1}" != "-c" ; then 
  1617.   echo shar: Will not clobber existing file \"'uucp2/src/lib/serialport.c'\"
  1618. else
  1619. echo shar: Extracting \"'uucp2/src/lib/serialport.c'\" \(2870 characters\)
  1620. sed "s/^X//" >'uucp2/src/lib/serialport.c' <<'END_OF_FILE'
  1621. X
  1622. X/*
  1623. X *  SERIALPORT.C
  1624. X *
  1625. X *  $Header: Beta:src/uucp/src/lib/RCS/serialport.c,v 1.1 90/02/02 12:08:21 dillon Exp Locker: dillon $
  1626. X *
  1627. X *  (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  1628. X *
  1629. X *  Serial Port locking to prevent collisions between, say, a Getty
  1630. X *  accepting a login sequence and a uucico calling up another machine.
  1631. X *
  1632. X *  The existance of the public port indicates a lock.    People waiting
  1633. X *  for the lock PutMsg() EXEC messages to the port.  Upon unlocking,
  1634. X *  the unlocker will deallocate the port only if no messages are
  1635. X *  pending, else it will ReplyMsg() the first message in the queue
  1636. X *  and NOT deallocate the port.
  1637. X *
  1638. X *  On receiving a message back you own the port and its memory
  1639. X */
  1640. X
  1641. X#include <exec/types.h>
  1642. X#include <exec/ports.h>
  1643. X#include <exec/memory.h>
  1644. X#include "protos.h"
  1645. X#include <stdio.h>
  1646. X#include "config.h"
  1647. X
  1648. Xtypedef struct MsgPort    PORT;
  1649. Xtypedef struct Message    MSG;
  1650. X
  1651. Xstruct SMsgPort {
  1652. X    PORT    Port;
  1653. X    short   NameLen;
  1654. X    short   Reserved;
  1655. X};
  1656. X
  1657. Xtypedef struct SMsgPort SPORT;
  1658. X
  1659. XPrototype void LockSerialPort(const char *, long);
  1660. XPrototype void UnLockSerialPort(const char *, long);
  1661. X
  1662. Xstatic SPORT    *SPLock;
  1663. X
  1664. Xint IAmGetty = 0;
  1665. X
  1666. Xvoid
  1667. XLockSerialPort(name, unit)
  1668. Xconst char *name;
  1669. Xlong unit;
  1670. X{
  1671. X    short namelen = strlen(name) + 32;
  1672. X    char *portname;
  1673. X    SPORT *sport;
  1674. X    PORT  *rport = NULL;
  1675. X    MSG   msg;
  1676. X
  1677. X    if (SPLock)
  1678. X    return;
  1679. X
  1680. X    portname = AllocMem(namelen, MEMF_PUBLIC | MEMF_CLEAR);
  1681. X
  1682. X    sprintf(portname, "SPLock-%d-%s", unit, name);
  1683. X
  1684. X    Forbid();
  1685. X    if (sport = (SPORT *)FindPort(portname)) {
  1686. X    rport = CreatePort(NULL, 0);
  1687. X    msg.mn_ReplyPort = rport;
  1688. X    msg.mn_Length = 0;
  1689. X    if (IAmGetty)
  1690. X        AddHead(&sport->Port.mp_MsgList, &msg);
  1691. X    else
  1692. X        AddTail(&sport->Port.mp_MsgList, &msg);
  1693. X    FreeMem(portname, namelen);
  1694. X    } else {
  1695. X    sport = AllocMem(sizeof(SPORT), MEMF_PUBLIC | MEMF_CLEAR);
  1696. X    sport->Port.mp_Node.ln_Name = portname;
  1697. X    sport->Port.mp_Node.ln_Type = NT_MSGPORT;
  1698. X    sport->Port.mp_Flags = PA_IGNORE;
  1699. X    sport->NameLen = namelen;
  1700. X    AddPort(&sport->Port);
  1701. X    }
  1702. X    Permit();
  1703. X    SPLock = sport;
  1704. X    if (rport) {            /*  wait for message to be returned */
  1705. X    WaitPort(rport);
  1706. X    DeletePort(rport);
  1707. X    }
  1708. X}
  1709. X
  1710. X/*
  1711. X *  Unlock the serial port.  If I am NOT the Getty then delay before
  1712. X *  unlocking to give the Getty a chance to take the next lock (it takes
  1713. X *  about a second for the Getty to realize the serial.device has been
  1714. X *  closed and try to take the lock.
  1715. X */
  1716. X
  1717. Xvoid
  1718. XUnLockSerialPort(name, unit)
  1719. Xconst char *name;
  1720. Xlong unit;
  1721. X{
  1722. X    MSG *msg;
  1723. X
  1724. X    if (SPLock) {
  1725. X    if (IAmGetty == 0)
  1726. X        sleep(2);
  1727. X    Forbid();
  1728. X    if (msg = GetMsg(&SPLock->Port)) {  /*  somebody else wants it */
  1729. X        ReplyMsg(msg);
  1730. X    } else {            /*  nobody else wants it   */
  1731. X        RemPort(&SPLock->Port);
  1732. X        FreeMem(SPLock->Port.mp_Node.ln_Name, SPLock->NameLen);
  1733. X        FreeMem(SPLock, sizeof(SPORT));
  1734. X    }
  1735. X    Permit();
  1736. X    SPLock = NULL;
  1737. X    }
  1738. X}
  1739. X
  1740. END_OF_FILE
  1741. if test 2870 -ne `wc -c <'uucp2/src/lib/serialport.c'`; then
  1742.     echo shar: \"'uucp2/src/lib/serialport.c'\" unpacked with wrong size!
  1743. fi
  1744. # end of 'uucp2/src/lib/serialport.c'
  1745. fi
  1746. if test -f 'uucp2/src/util/from.c' -a "${1}" != "-c" ; then 
  1747.   echo shar: Will not clobber existing file \"'uucp2/src/util/from.c'\"
  1748. else
  1749. echo shar: Extracting \"'uucp2/src/util/from.c'\" \(2606 characters\)
  1750. sed "s/^X//" >'uucp2/src/util/from.c' <<'END_OF_FILE'
  1751. X
  1752. X/*
  1753. X *  FROM.C
  1754. X *
  1755. X *  FROM [user]
  1756. X *
  1757. X *  $Header: Beta:src/uucp/src/MUtil/RCS/from.c,v 1.3 90/04/03 20:44:31 dillon Exp Locker: dillon $
  1758. X *
  1759. X *  Displays From: and Subject fields, attempts to find personal name
  1760. X *  in From: field.  If user not specified searches UULIB:Config
  1761. X *  for UserName.
  1762. X */
  1763. X
  1764. X#include <stdio.h>
  1765. X#include <stdlib.h>
  1766. X#include <config.h>
  1767. X#include "version.h"
  1768. X
  1769. XIDENT(".02");
  1770. X
  1771. XLocal void FromUser(char *);
  1772. XLocal char *ExtractPersonalName(char *);
  1773. X
  1774. Xvoid
  1775. Xmain(ac, av)
  1776. Xchar *av[];
  1777. X{
  1778. X    char haduser = 0;
  1779. X    short i;
  1780. X
  1781. X    for (i = 1; i < ac; ++i) {
  1782. X    if (av[i][0] != '-') {
  1783. X        haduser = 1;
  1784. X        FromUser(av[i]);
  1785. X    }
  1786. X    }
  1787. X    if (haduser == 0) {
  1788. X    char *user;
  1789. X    if (user = FindConfig(USERNAME))
  1790. X        FromUser(user);
  1791. X    else
  1792. X        printf("%s, no 'UserName' entry!\n", MakeConfigPath(UULIB, "Config"));
  1793. X    }
  1794. X}
  1795. X
  1796. Xvoid
  1797. XFromUser(user)
  1798. Xchar *user;
  1799. X{
  1800. X    static char Buf[256];
  1801. X    static char FromLine[256];
  1802. X    static char SubjLine[256];
  1803. X    char *file = malloc(strlen(user) + 32);
  1804. X    char *fromstr;
  1805. X    FILE *fi;
  1806. X    long msgno = 0;
  1807. X
  1808. X    strcpy(file, MakeConfigPath(UUMAIL, user));
  1809. X    if (fi = fopen(file, "r")) {
  1810. X    while (fgets(Buf, 256, fi)) {
  1811. X
  1812. X        /*
  1813. X         *    Start of message
  1814. X         */
  1815. X
  1816. X        if (strncmp(Buf, "From ", 5) != 0)
  1817. X        continue;
  1818. X
  1819. X        ++msgno;
  1820. X
  1821. X        /*
  1822. X         *    Scan headers for From: and Subject:
  1823. X         *    Headers end with a blank line.
  1824. X         */
  1825. X
  1826. X        FromLine[0] = 0;
  1827. X        SubjLine[0] = '\n';
  1828. X        SubjLine[1] = 0;
  1829. X
  1830. X        while (fgets(Buf, 256, fi) && Buf[0] != '\n') {
  1831. X        if (strncmp(Buf, "From:", 5) == 0)
  1832. X            strcpy(FromLine, Buf + 5);
  1833. X        if (strncmp(Buf, "Subject:", 8) == 0)
  1834. X            strcpy(SubjLine, Buf + 8);
  1835. X        }
  1836. X
  1837. X        fromstr = ExtractPersonalName(FromLine);
  1838. X        printf("%-3d %-20.20s  %-20.20s\n", msgno, fromstr, SubjLine);
  1839. X    }
  1840. X    }
  1841. X}
  1842. X
  1843. X/*
  1844. X *  Search for (name) or name <addr> or <addr> name
  1845. X */
  1846. X
  1847. Xchar *
  1848. XExtractPersonalName(str)
  1849. Xchar *str;
  1850. X{
  1851. X    char *p1, *p2;
  1852. X    char sp = 1;
  1853. X
  1854. X    for (p1 = str; *p1; ++p1) {
  1855. X    if (*p1 == '<') {
  1856. X        if (sp == 0) {      /*  name before <addr>  */
  1857. X        p2 = p1 - 1;
  1858. X        p1 = str;
  1859. X        break;
  1860. X        }
  1861. X                /*  name after <addr>    */
  1862. X        while (*p1 && *p1 != '>')
  1863. X        ++p1;
  1864. X        if (*p1 == '>')
  1865. X        ++p1;
  1866. X        p2 = str + strlen(str) - 1;
  1867. X        break;
  1868. X    }
  1869. X    if (*p1 == '(') {
  1870. X        ++p1;
  1871. X        for (p2 = p1; *p2 && *p2 != ')'; ++p2);
  1872. X        if (*p2 == ')')
  1873. X        --p2;
  1874. X        break;
  1875. X    }
  1876. X    if (*p1 != ' ' && *p1 != 9)
  1877. X        sp = 0;
  1878. X    }
  1879. X    if (*p1 == 0) { /*  could find a personal name! */
  1880. X    p1 = str;
  1881. X    p2 = str + strlen(str) - 1;
  1882. X    }
  1883. X    while (p2 >= p1 && (*p2 == '\n' || *p2 == ' ' || *p2 == 9))
  1884. X    --p2;
  1885. X    ++p2;
  1886. X    if (p2 < p1)
  1887. X    p2 = p1;
  1888. X    *p2 = 0;
  1889. X    return(p1);
  1890. X}
  1891. X
  1892. END_OF_FILE
  1893. if test 2606 -ne `wc -c <'uucp2/src/util/from.c'`; then
  1894.     echo shar: \"'uucp2/src/util/from.c'\" unpacked with wrong size!
  1895. fi
  1896. # end of 'uucp2/src/util/from.c'
  1897. fi
  1898. if test -f 'uucp2/src/util/inform.c' -a "${1}" != "-c" ; then 
  1899.   echo shar: Will not clobber existing file \"'uucp2/src/util/inform.c'\"
  1900. else
  1901. echo shar: Extracting \"'uucp2/src/util/inform.c'\" \(3077 characters\)
  1902. sed "s/^X//" >'uucp2/src/util/inform.c' <<'END_OF_FILE'
  1903. X
  1904. X/*
  1905. X *  INFORM how click-cmd "text" [-x file-to-delete-on-exit]
  1906. X *
  1907. X *  $Header: Beta:src/uucp/src/MUtil/RCS/inform.c,v 1.2 90/04/03 20:44:58 dillon Exp Locker: dillon $
  1908. X *
  1909. X *  (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  1910. X *
  1911. X *  INFORM mail - "You have new mail"
  1912. X *
  1913. X *  Brings up an unobtrusive window saying that you have new mail and waits
  1914. X *  for the user to hit the close box or double click the title bar.  If
  1915. X *  the title bar is double clicked
  1916. X *
  1917. X *  Multiple runs of the same command with the same 'how' field do not cause
  1918. X *  further requesters to come up.  Note that sendmail also has a lockout
  1919. X *  mechanism by way of a temporary file which is not deleted until
  1920. X *  inform exits (the -x option).
  1921. X */
  1922. X
  1923. X#include <exec/types.h>
  1924. X#include <exec/ports.h>
  1925. X#include <intuition/intuition.h>
  1926. X
  1927. X#include <stdio.h>
  1928. X#include <stdlib.h>
  1929. X#include "protos.h"
  1930. X#include "config.h"
  1931. X#include "version.h"
  1932. X
  1933. X#define TBFI    0   /*    meaningless */
  1934. X
  1935. XIDENT(".00");
  1936. X
  1937. Xstruct Window    *Win;
  1938. Xstruct MsgPort    *Port;
  1939. X
  1940. Xstruct IntuitionBase *IntuitionBase;
  1941. Xstruct GfxBase         *GfxBase;
  1942. X
  1943. Xstruct NewWindow Nw = {
  1944. X    320, 0, TBFI, 10, -1, -1,
  1945. X    CLOSEWINDOW|MOUSEBUTTONS,
  1946. X    WINDOWCLOSE|BACKDROP|SIMPLE_REFRESH|RMBTRAP|NOCAREREFRESH,
  1947. X    NULL, NULL, TBFI, NULL, NULL, 0, 0, -1, -1, WBENCHSCREEN
  1948. X};
  1949. X
  1950. XLocal void xexit(int);
  1951. XLocal int WaitWinAction(void);
  1952. X
  1953. Xchar *DelFile;
  1954. X
  1955. Xvoid
  1956. Xmain(ac, av)
  1957. Xchar *av[];
  1958. X{
  1959. X    static char pubname[64];
  1960. X
  1961. X    {
  1962. X    short i;
  1963. X    for (i = 4; i < ac; ++i) {
  1964. X        char *ptr = av[i];
  1965. X        if (*ptr == '-') {
  1966. X        ptr += 2;
  1967. X        switch(ptr[-1]) {
  1968. X        case 'x':
  1969. X            if (*ptr)
  1970. X            DelFile = ptr;
  1971. X            else
  1972. X            DelFile = av[++i];
  1973. X            break;
  1974. X        }
  1975. X        }
  1976. X    }
  1977. X    }
  1978. X
  1979. X    if (ac < 3) {
  1980. X    fprintf(stderr, "Inform id clickcmd text\n");
  1981. X    exit(1);
  1982. X    }
  1983. X    sprintf(pubname, "Inform.%s", av[1]);
  1984. X    LockFile("T:Inform");
  1985. X    if (FindPort(pubname) == NULL)
  1986. X    Port = CreatePort(pubname, 0);
  1987. X    UnLockFile("T:Inform");
  1988. X    if (Port) {
  1989. X    IntuitionBase = OpenLibrary("intuition.library", 0);
  1990. X    GfxBase       = OpenLibrary("graphics.library", 0);
  1991. X    if (IntuitionBase && GfxBase) {
  1992. X        Nw.Width = strlen(av[3]) * 8 + 32;
  1993. X        Nw.Title = (UBYTE *)av[3];
  1994. X        if (Win = OpenWindow(&Nw)) {
  1995. X        ShowTitle(Win->WScreen, 0);
  1996. X        if (WaitWinAction()) {
  1997. X            Execute(av[2], NULL, NULL);
  1998. X        }
  1999. X        }
  2000. X    }
  2001. X    }
  2002. X    if (DelFile)
  2003. X    remove(DelFile);
  2004. X    xexit(0);
  2005. X}
  2006. X
  2007. XLocal int
  2008. XWaitWinAction()
  2009. X{
  2010. X    short click = 0;
  2011. X    short notdone = 1;
  2012. X    struct IntuiMessage *im;
  2013. X
  2014. X    while (notdone) {
  2015. X    WaitPort(Win->UserPort);
  2016. X    while (im = (struct IntuiMessage *)GetMsg(Win->UserPort)) {
  2017. X        switch(im->Class) {
  2018. X        case MOUSEBUTTONS:
  2019. X        if (im->Code == SELECTDOWN) {
  2020. X            click = 1;
  2021. X            notdone = 0;
  2022. X            break;
  2023. X        }
  2024. X        break;
  2025. X        case CLOSEWINDOW:
  2026. X        notdone = 0;
  2027. X        break;
  2028. X        }
  2029. X        ReplyMsg((struct Message *)im);
  2030. X    }
  2031. X    }
  2032. X    CloseWindow(Win);
  2033. X    Win = NULL;
  2034. X    return((int)click);
  2035. X}
  2036. X
  2037. XLocal void
  2038. Xxexit(code)
  2039. X{
  2040. X    if (Win)
  2041. X    CloseWindow(Win);
  2042. X    if (GfxBase)
  2043. X    CloseLibrary(GfxBase);
  2044. X    if (IntuitionBase)
  2045. X    CloseLibrary(IntuitionBase);
  2046. X    if (Port) {
  2047. X    Forbid();
  2048. X    DeletePort(Port);
  2049. X    Permit();
  2050. X    }
  2051. X    exit(code);
  2052. X}
  2053. X
  2054. END_OF_FILE
  2055. if test 3077 -ne `wc -c <'uucp2/src/util/inform.c'`; then
  2056.     echo shar: \"'uucp2/src/util/inform.c'\" unpacked with wrong size!
  2057. fi
  2058. # end of 'uucp2/src/util/inform.c'
  2059. fi
  2060. if test -f 'uucp2/src/util/uusplit.c' -a "${1}" != "-c" ; then 
  2061.   echo shar: Will not clobber existing file \"'uucp2/src/util/uusplit.c'\"
  2062. else
  2063. echo shar: Extracting \"'uucp2/src/util/uusplit.c'\" \(2694 characters\)
  2064. sed "s/^X//" >'uucp2/src/util/uusplit.c' <<'END_OF_FILE'
  2065. X
  2066. X/*
  2067. X *  UUSPLIT.C
  2068. X *
  2069. X *  uusplit file [outprefix] [-b #bytes] [-v]
  2070. X *
  2071. X *  $Header: Beta:src/uucp/src/MUtil/RCS/uusplit.c,v 1.1 90/03/19 14:06:36 dillon Exp Locker: dillon $
  2072. X *
  2073. X *  take the binary 'file' and split into sections of 50KBytes each, uuencoding
  2074. X *  each section independantly.  Result:
  2075. X *
  2076. X *    outprefix.01.uue,   outprefix.02.uue ,etc...  uuencoding
  2077. X *    outprefix.01,        outprefix.02, etc...
  2078. X *
  2079. X *  File segments are uuencoded.  uuencode must be in your path.    Calculate
  2080. X *  a 1.5 expansion uuencoding the file.
  2081. X */
  2082. X
  2083. X#include <stdio.h>
  2084. X#include <stdlib.h>
  2085. X#include "version.h"
  2086. X
  2087. XIDENT(".00");
  2088. X
  2089. XLocal void DumpSegment(FILE *, short, long, char *);
  2090. XLocal void run_cmd(char *);
  2091. XLocal void help(void);
  2092. X
  2093. Xshort    Verbose;
  2094. X
  2095. Xmain(ac, av)
  2096. Xchar *av[];
  2097. X{
  2098. X    long bytes = 50000;
  2099. X    short i;
  2100. X    char *file    = NULL;
  2101. X    char *outpf = NULL;
  2102. X    FILE *fi;
  2103. X    long size;
  2104. X    long n;
  2105. X
  2106. X    for (i = 1; i < ac; ++i) {
  2107. X    char *ptr = av[i];
  2108. X    if (*ptr == '-') {
  2109. X        ptr += 2;
  2110. X        switch(ptr[-1]) {
  2111. X        case 'v':
  2112. X        Verbose = 1;
  2113. X        break;
  2114. X        case 'b':
  2115. X        if (*ptr)
  2116. X            bytes = atoi(ptr);
  2117. X        else
  2118. X            bytes = atoi(av[++i]);
  2119. X        break;
  2120. X        default:
  2121. X        help();
  2122. X        }
  2123. X    } else {
  2124. X        if (file == NULL)
  2125. X        file = ptr;
  2126. X        else if (outpf == NULL)
  2127. X        outpf = ptr;
  2128. X        else
  2129. X        help();
  2130. X    }
  2131. X    }
  2132. X
  2133. X    bytes = bytes * 2 / 3;    /*  assume uuencode expands file 1.5x    */
  2134. X
  2135. X    if (file == NULL)
  2136. X    help();
  2137. X    if (outpf == NULL)
  2138. X    outpf = file;
  2139. X
  2140. X    fi = fopen(file, "r");
  2141. X    if (fi == NULL) {
  2142. X    printf("couldn't open %s\n", file);
  2143. X    exit(1);
  2144. X    }
  2145. X    fseek(fi, 0L, 2);
  2146. X    size = ftell(fi);
  2147. X    for (i = n = 0; n < size; n += bytes) {
  2148. X    long b = size - n;
  2149. X
  2150. X    if (b > bytes)
  2151. X        b = bytes;
  2152. X    fseek(fi, n, 0);
  2153. X    DumpSegment(fi, (short)(i + 1), b, outpf);
  2154. X    ++i;
  2155. X    }
  2156. X    fclose(fi);
  2157. X    return(0);
  2158. X}
  2159. X
  2160. Xvoid
  2161. Xhelp()
  2162. X{
  2163. X    puts("uusplit file [outprefix] [-b bytes] [-v]");
  2164. X    exit(1);
  2165. X}
  2166. X
  2167. Xvoid
  2168. XDumpSegment(fi, i, bytes, outprefix)
  2169. XFILE *fi;
  2170. Xshort i;
  2171. Xlong bytes;
  2172. Xchar *outprefix;
  2173. X{
  2174. X    static char Name1[256];
  2175. X    static char Name2[256];
  2176. X    static char Name3[256];
  2177. X    static char Buf[4096];
  2178. X    long n;
  2179. X    FILE *fo;
  2180. X
  2181. X    sprintf(Name1, "T:uusplit.%02d", i);
  2182. X    sprintf(Name2, "%s.%02d", outprefix, i);
  2183. X    sprintf(Name3, "%s.%02d.uue", outprefix, i);
  2184. X
  2185. X    fo = fopen(Name1, "w");
  2186. X    if (fo == NULL) {
  2187. X    printf("couldn't create %s\n", Name1);
  2188. X    exit(1);
  2189. X    }
  2190. X
  2191. X    while (bytes) {
  2192. X    n = (bytes > sizeof(Buf)) ? sizeof(Buf) : bytes;
  2193. X    fread(Buf, 1, n, fi);
  2194. X    fwrite(Buf, 1, n, fo);
  2195. X    bytes -= n;
  2196. X    }
  2197. X    fclose(fo);
  2198. X    sprintf(Buf, "uuencode >%s %s %s", Name3, Name1, Name2);
  2199. X    run_cmd(Buf);
  2200. X    remove(Name1);
  2201. X}
  2202. X
  2203. Xvoid
  2204. Xrun_cmd(buf)
  2205. Xchar *buf;
  2206. X{
  2207. X    if (Verbose) {
  2208. X    puts(buf);
  2209. X    fflush(stdout);
  2210. X    }
  2211. X    Execute(buf, NULL, NULL);
  2212. X}
  2213. X
  2214. END_OF_FILE
  2215. if test 2694 -ne `wc -c <'uucp2/src/util/uusplit.c'`; then
  2216.     echo shar: \"'uucp2/src/util/uusplit.c'\" unpacked with wrong size!
  2217. fi
  2218. # end of 'uucp2/src/util/uusplit.c'
  2219. fi
  2220. if test -f 'uucp2/src/uucico/uuxqt.c' -a "${1}" != "-c" ; then 
  2221.   echo shar: Will not clobber existing file \"'uucp2/src/uucico/uuxqt.c'\"
  2222. else
  2223. echo shar: Extracting \"'uucp2/src/uucico/uuxqt.c'\" \(2653 characters\)
  2224. sed "s/^X//" >'uucp2/src/uucico/uuxqt.c' <<'END_OF_FILE'
  2225. X
  2226. X/*
  2227. X *  UUXQT.C by William Loftus
  2228. X *  Copyright 1988 by William Loftus.    All rights reserved.
  2229. X *  Changes Copyright 1990 by Matthew Dillon, All Rights Reserved
  2230. X *
  2231. X *  $Header: Beta:src/uucp/src/uucico/RCS/uuxqt.c,v 1.1 90/02/02 11:55:58 dillon Exp Locker: dillon $
  2232. X */
  2233. X
  2234. X#include <stdio.h>
  2235. X#include <string.h>
  2236. X#include "version.h"
  2237. X
  2238. XIDENT(".03");
  2239. X
  2240. Xstatic char names[MAXFILES*16];
  2241. Xstatic char *pointers[MAXFILES];
  2242. Xstatic int file_pointer;
  2243. Xstatic int error;
  2244. Xstatic char *xfile;
  2245. Xstatic char dfile[128];
  2246. Xstatic char cmd[1024];
  2247. Xstatic char ccmd[128];
  2248. Xstatic char ccmd_args[128];
  2249. Xstatic char buf[128];
  2250. Xstatic char path[256];
  2251. X
  2252. X#define DELIM " \t\n\r"
  2253. X
  2254. Xint
  2255. Xbrk()
  2256. X{
  2257. X    return(0);
  2258. X}
  2259. X
  2260. Xchar *
  2261. Xwork_scan()
  2262. X{
  2263. X    static char name[128];
  2264. X    int count;
  2265. X
  2266. X    file_pointer = 0;
  2267. X
  2268. X    strcpy(name, MakeConfigPath(UUSPOOL, "X.#?"));
  2269. X
  2270. X    count = getfnl(name,names,sizeof(names),0);
  2271. X
  2272. X    if (count > 0) {
  2273. X    printf("New files have arrived.\n");
  2274. X
  2275. X    if (strbpl(pointers,MAXFILES,names) != count) {
  2276. X        printf("Too many execute files\n");
  2277. X        return (char *)NULL;
  2278. X    }
  2279. X    } else {
  2280. X    return (char *)NULL;
  2281. X    }
  2282. X    return (char *)1;
  2283. X}
  2284. X
  2285. Xchar *
  2286. Xwork_next()
  2287. X{
  2288. X    return pointers[file_pointer++];
  2289. X}
  2290. X
  2291. Xparse(x)
  2292. Xchar *x;
  2293. X{
  2294. X    FILE *fp;
  2295. X    char *tmp;
  2296. X
  2297. X    fp = fopen(x, "r");
  2298. X    if (fp == (char *)NULL) {
  2299. X    printf("Can't open file %s\n",x);
  2300. X    chdir(path);
  2301. X    return(0);
  2302. X    }
  2303. X    while (fgets(buf, sizeof buf, fp)) {
  2304. X    if (strncmp(buf, "F", 1) == 0)
  2305. X        strcpy(dfile, strtok(&buf[1],DELIM));
  2306. X    else if (strncmp(buf, "C", 1) == 0)
  2307. X        strcpy(ccmd, strtok(&buf[1],DELIM));
  2308. X    strcpy(ccmd_args, strtok(NULL, DELIM));
  2309. X    while ((tmp = (char *)strtok(NULL, DELIM)) != NULL) {
  2310. X         strcat(ccmd_args, " ");
  2311. X         strcat(ccmd_args, tmp);
  2312. X    }
  2313. X    }
  2314. X
  2315. X    if (strncmp(ccmd, "rmail", 5) == 0) {
  2316. X    sprintf(cmd,"%s < %s %s", GetConfigProgram(RMAIL), dfile, ccmd_args);
  2317. X    } else if (strncmp(ccmd, "cunbatch", 5) == 0) {
  2318. X    sprintf(cmd,"%s < %s %s", GetConfigProgram(CUNBATCH), dfile, ccmd_args);
  2319. X    } else if (strncmp(ccmd, "rnews", 5) == 0) {
  2320. X    sprintf(cmd,"%s < %s %s", GetConfigProgram(RNEWS), dfile, "UseNet");
  2321. X    } else {
  2322. X    printf("Unknown command request %s  - Operation Aborted -\n", ccmd);
  2323. X    error = 1;
  2324. X    }
  2325. X    fclose(fp);
  2326. X    return(1);
  2327. X}
  2328. X
  2329. X
  2330. Xvoid
  2331. Xmain()
  2332. X{
  2333. X    onbreak(brk);
  2334. X
  2335. X    getcwd(path,sizeof(path));
  2336. X    chdir(GetConfigDir(UUSPOOL));
  2337. X    LockFile("UUXQT");
  2338. X    if (work_scan() != (char *)NULL) {
  2339. X    while ((xfile = work_next()) != (char *)NULL) {
  2340. X        LockFile(xfile);
  2341. X        if (parse(xfile)) {
  2342. X        int syserr;
  2343. X
  2344. X        syserr = system(cmd);
  2345. X        if (syserr == 0 && error != 1) {
  2346. X            remove(xfile);
  2347. X            remove(dfile);
  2348. X        }
  2349. X        }
  2350. X        UnLockFile(xfile);
  2351. X    }
  2352. X    }
  2353. X    UnLockFile("UUXQT");
  2354. X    chdir(path);
  2355. X}
  2356. X
  2357. END_OF_FILE
  2358. if test 2653 -ne `wc -c <'uucp2/src/uucico/uuxqt.c'`; then
  2359.     echo shar: \"'uucp2/src/uucico/uuxqt.c'\" unpacked with wrong size!
  2360. fi
  2361. # end of 'uucp2/src/uucico/uuxqt.c'
  2362. fi
  2363. if test -f 'uucp2/src/uucico/version.doc' -a "${1}" != "-c" ; then 
  2364.   echo shar: Will not clobber existing file \"'uucp2/src/uucico/version.doc'\"
  2365. else
  2366. echo shar: Extracting \"'uucp2/src/uucico/version.doc'\" \(2880 characters\)
  2367. sed "s/^X//" >'uucp2/src/uucico/version.doc' <<'END_OF_FILE'
  2368. X
  2369. X<all-Programs>
  2370. X    Dec-89  Matthew Dillon.  Modified to conform with my release.
  2371. X        Specifically, now use common library routines in uucp:src/lib,
  2372. X        file locking routines, logging routines, etc...
  2373. X
  2374. X    Apr-89  Matthew Dillon.  Prototyping added (not 100% but method now
  2375. X        exists set so people don't go off and make up their own schemes)
  2376. X
  2377. X
  2378. XUUXQT:
  2379. X    .03 Locks at beginning, unlocks at end (sequences multiply run
  2380. X        UUXQTs)
  2381. X
  2382. X    .02 File limit upped to 1000, conforms with new library routines
  2383. X        to obtain directory paths.
  2384. X
  2385. X    .01 First sub release number assigned.
  2386. X
  2387. X
  2388. X    11-Jul-88 by Dan Schein
  2389. X
  2390. X        Added support for unknown command request(s)
  2391. X        Added support for a RMAIL command
  2392. X        Added "New Files Received." message
  2393. X        Added Beta Version number
  2394. X
  2395. XUUCICO:
  2396. X    .11    GIO.C fixed up yet again
  2397. X
  2398. X        ~ paths fixed in all cases, refer to MAN/UUCP
  2399. X
  2400. X        Time Restrictions added by Christopher A. Wichura.
  2401. X
  2402. X
  2403. X    .10    Allow two forms for the dial string in the L.Sys file:
  2404. X            5551234     (just the number)
  2405. X            ATDT5551234    (full AT command)
  2406. X            ATM1DT5551234    (another example)
  2407. X
  2408. X        This allows you to specify options specific to the
  2409. X        particular system you are calling.  Make sure the
  2410. X        appropriate AT commands are listed in the GETTY
  2411. X        command line to 'reset' the modem properly.
  2412. X
  2413. X    .09    Allow combined -r1 -ssystem name ... means "Call this
  2414. X        particular system only if there is work for it"
  2415. X
  2416. X    .08
  2417. X        New protocol module GIO.C supports window size of 7
  2418. X
  2419. X        File limit upped to a 1000 from 300.
  2420. X
  2421. X    .07
  2422. X        Now sends manual ack (RR packet) instead of relying
  2423. X        on piggy-backed ack.
  2424. X
  2425. X    .06
  2426. X        as of date 25 January 1989
  2427. X
  2428. X    .05
  2429. X        G protocol now windows, window = 2.  Normally
  2430. X        arbitrates for window size, can be defeated (forced to
  2431. X        1) by using -n option.
  2432. X
  2433. X        Accepts filenames ~/path or ~user/path.  ~/path uses
  2434. X        UUPUB: while ~user/path looks up the home directory
  2435. X        in the Getty:Passwd file, defaulting to UUPUB: if
  2436. X        the requested user could not be found.
  2437. X
  2438. X    .04
  2439. X        only deletes queue files in a set if ALL make it
  2440. X        across... before would delete each file individually.
  2441. X
  2442. X        added security feature, does not allow remote end
  2443. X        to send C.#? files to our uuspool:
  2444. X
  2445. X    .02
  2446. X        G protocol rewritten from scratch
  2447. X
  2448. X    .01
  2449. X        Security list (UULIB:Security) allowed directories
  2450. X        for remote requests.
  2451. X
  2452. X        Getty support
  2453. X
  2454. X        File Locking (lib/lockfile.c)
  2455. X
  2456. XUUCP:
  2457. X    .01    Changed to use library routines to obtain directory paths
  2458. X    .00    First sub release assigned
  2459. X
  2460. XUUNAME:
  2461. X    .01    Changed to use library routines to obtain directory paths
  2462. X    .00    First sub release assigned
  2463. X
  2464. XUUX:
  2465. X    .02    Changed to use library routines to obtain directory paths
  2466. X    .01    Uses UULIB: instead of UUCP:LIB
  2467. X
  2468. XUUHOSTS:
  2469. X    .02    Changed to use library routines to obtain directory paths
  2470. X    .01    Uses UULIB: instead of UUCP:LIB
  2471. X
  2472. XUUPOLL:
  2473. X    .03    Changed to use library routines to obtain directory paths
  2474. X    .02    Uses UULIB: instead of UUCP:LIB
  2475. X        Uses run >nil: <nil: instead of brun
  2476. X
  2477. END_OF_FILE
  2478. if test 2880 -ne `wc -c <'uucp2/src/uucico/version.doc'`; then
  2479.     echo shar: \"'uucp2/src/uucico/version.doc'\" unpacked with wrong size!
  2480. fi
  2481. # end of 'uucp2/src/uucico/version.doc'
  2482. fi
  2483. if test -f 'uucp2/src/uuser/uuser.doc' -a "${1}" != "-c" ; then 
  2484.   echo shar: Will not clobber existing file \"'uucp2/src/uuser/uuser.doc'\"
  2485. else
  2486. echo shar: Extracting \"'uucp2/src/uuser/uuser.doc'\" \(2143 characters\)
  2487. sed "s/^X//" >'uucp2/src/uuser/uuser.doc' <<'END_OF_FILE'
  2488. X
  2489. X                UUSER.DOC
  2490. X
  2491. X                UUSER V1.00 Beta
  2492. X
  2493. X    $Header: Beta:src/uucp/src/uuser/RCS/uuser.doc,v 1.1 90/02/02 12:10:18 dillon Exp Locker: dillon $
  2494. X
  2495. X    UUSER: (C) Copyright 1989-1990 by Matthew Dillon,  All Rights Reserved.
  2496. X
  2497. X
  2498. X    Currently UUSER: works only with single sessions started
  2499. X    by Getty (this has to do with how UUSER: deals with carrier
  2500. X    detect).  THIS WILL BE FIXED.
  2501. X
  2502. X    Openning UUSER:
  2503. X
  2504. X    fopen("UUSER:devicename/unit/options", ...);
  2505. X
  2506. X    Example:
  2507. X            (suggested)
  2508. X
  2509. X    int  fd = open("UUSER:serial.device/0/R1000", O_RDWR | O_CREAT | O_TRUNC);
  2510. X
  2511. X            (also can do this -- see below for problems using
  2512. X             stdio to read)
  2513. X
  2514. X    FILE *rfi = fopen("UUSER:serial.device/0/R1000", "r");
  2515. X    FILE *wfi = fopen("UUSER:serial.device/0/R1000", "w");
  2516. X
  2517. X
  2518. X    Features:
  2519. X
  2520. X    * 1K asynchronous write buffer for each file handle.  I.E.
  2521. X      your write() will return when 1K or less remains to be
  2522. X      written (UUSER: has a 1K buffer for spooling these per
  2523. X      file handle)
  2524. X
  2525. X    * selectable read timeout
  2526. X
  2527. X    * read poll
  2528. X
  2529. X    * carrier lost handling
  2530. X
  2531. X    General:
  2532. X
  2533. X    (1) Use Level 1 I/O if you can (read/write)
  2534. X        read() returns 0 on timeout, -1 on carrier lost
  2535. X        otherwise, read() returns the immediate number of
  2536. X        data bytes ready up to the amount you requested.
  2537. X        (i.e. if you read(0,buf,256) you can get anywhere from
  2538. X        -1, 0, 1 to 256 back).
  2539. X
  2540. X        write() returns the number you wrote or -1 (lost carrier)
  2541. X
  2542. X        To 'poll' data ready you can read(0, NULL, 0) .. reading
  2543. X        0 bytes returns 0 (data ready) or -1 (data not ready).
  2544. X        NOTE: 0 (data ready) will be returned if carrier is lost
  2545. X        when you read 0 bytes... this is so your program thinks
  2546. X        data is ready and when it does a real read it finds that
  2547. X        carrier was lost!
  2548. X
  2549. X    (2) If you want to use Level 2 I/O (stdio) I suggest you use
  2550. X        it for writing only.  If you really want to use it for
  2551. X        reading remember that the timeout will cause an EOF
  2552. X        condition which must be cleared (clrerr()).  And you
  2553. X        must call ferror() to determine whether an EOF is an
  2554. X        EOF (timeout()) or an actual error (lost carrier).
  2555. X
  2556. X    REFER TO UUSERDUMP.C for a working source example.
  2557. X
  2558. X
  2559. END_OF_FILE
  2560. if test 2143 -ne `wc -c <'uucp2/src/uuser/uuser.doc'`; then
  2561.     echo shar: \"'uucp2/src/uuser/uuser.doc'\" unpacked with wrong size!
  2562. fi
  2563. # end of 'uucp2/src/uuser/uuser.doc'
  2564. fi
  2565. echo shar: End of archive 3 \(of 12\).
  2566. cp /dev/null ark3isdone
  2567. MISSING=""
  2568. for I in 1 2 3 4 5 6 7 8 9 10 11 12 ; do
  2569.     if test ! -f ark${I}isdone ; then
  2570.     MISSING="${MISSING} ${I}"
  2571.     fi
  2572. done
  2573. if test "${MISSING}" = "" ; then
  2574.     echo You have unpacked all 12 archives.
  2575.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2576. else
  2577.     echo You still need to unpack the following archives:
  2578.     echo "        " ${MISSING}
  2579. fi
  2580. ##  End of shell archive.
  2581. exit 0
  2582. -- 
  2583. Mail submissions (sources or binaries) to <amiga@cs.odu.edu>.
  2584. Mail comments to the moderator at <amiga-request@cs.odu.edu>.
  2585. Post requests for sources, and general discussion to comp.sys.amiga.
  2586.